diff --git a/.github/actions/setup-haskell/action.yml b/.github/actions/setup-haskell/action.yml index 65fa920b7..a3c2144d7 100644 --- a/.github/actions/setup-haskell/action.yml +++ b/.github/actions/setup-haskell/action.yml @@ -22,7 +22,7 @@ runs: steps: - id: setup-haskell name: Setup Haskell - uses: haskell/actions/setup@v2 + uses: haskell-actions/setup@v2 with: ghc-version: ${{ inputs.ghc-version }} cabal-version: ${{ inputs.cabal-version }} diff --git a/.github/workflows/build-vehicle-python.yml b/.github/workflows/build-vehicle-python.yml index 49cf2f6db..ce478c9c0 100644 --- a/.github/workflows/build-vehicle-python.yml +++ b/.github/workflows/build-vehicle-python.yml @@ -57,7 +57,7 @@ jobs: cabal-version: ${{ env.DEFAULT_CABAL_VERSION }} - name: Build wheel - uses: pypa/cibuildwheel@v2.16.2 + uses: pypa/cibuildwheel@v2.16.4 with: package-dir: "./vehicle-python" output-dir: "./vehicle-python/wheelhouse" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 289d39427..65b347149 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -65,8 +65,9 @@ jobs: - name: Download wheelhouse uses: actions/download-artifact@v4 with: - pattern: "wheelhouse-*-*" - path: "wheelhouse" + pattern: wheelhouse-*-* + path: wheelhouse + merge-multiple: true - name: Publish to GitHub Releases uses: softprops/action-gh-release@v1 @@ -100,8 +101,9 @@ jobs: - name: Download wheelhouse uses: actions/download-artifact@v4 with: - name: wheelhouse + name: wheelhouse-*-* path: wheelhouse + merge-multiple: true - name: Publish to PyPI uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.hlint.yaml b/.hlint.yaml index a8831f31f..456f8eb0b 100644 --- a/.hlint.yaml +++ b/.hlint.yaml @@ -10,5 +10,3 @@ - ignore: { name: Redundant return } - ignore: { name: Avoid lambda } - ignore: { name: Redundant <&> } -# To generate a suitable file for HLint do: -# $ hlint --default > .hlint.yaml diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 34cf9083a..a617deb53 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -46,7 +46,7 @@ repos: - id: isort args: ["--profile", "black", "--filter-files"] - repo: https://github.com/psf/black - rev: "23.12.1" + rev: "24.1.1" hooks: - id: black - repo: https://github.com/pre-commit/mirrors-mypy diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1d8c9e63c..d0368634e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -329,6 +329,9 @@ The logging level can be changed by changing the command in the `test.json` file Some golden tests require external tools, such as the MarabouVerify test above. To run these tests, add `--test-option="--allowlist-externals="` to the test command, where `` is the name of the external dependency, such as `Marabou`. +Some golden tests diff extremely large files such as `.vcl-plan`s, for which the diff isn't very meaningful. +In order to only display the change in size for a given file type, add `--test-option="--sizeOnly="` to the test command, where `` is the extension of the chosen file type. + ##### Adding golden tests To create a new golden test, you can use the `new-golden-test` command. @@ -447,7 +450,7 @@ Ensure that [you have the source code](#getting-the-source) and that you have in vehicle --version ``` - This should print `0.11.0`. + This should print `0.11.1`. ### Building the Vehicle Python bindings @@ -570,14 +573,14 @@ Ensure that [you have the source code](#getting-the-source) and that you have in pipx run tox ``` -This creates the directory `dist` which contains "wheels", which are the binary distribution format for Python packages. These wheels will have file names such as `vehicle_lang-0.11.0-cp311-cp311-macosx_13_0_arm64`: +This creates the directory `dist` which contains "wheels", which are the binary distribution format for Python packages. These wheels will have file names such as `vehicle_lang-0.11.1-cp311-cp311-macosx_13_0_arm64`: ```sh # Supported # Python _____ # versions \ # vvvvvvvvvvv -vehicle_lang-0.11.0-cp311-cp311-macosx_13_0_arm64 +vehicle_lang-0.11.1-cp311-cp311-macosx_13_0_arm64 # ^^^^^^^^^^^^^^^^^ # Supported / # Operating System ______/ @@ -722,7 +725,7 @@ Ensure that [you have the source code](#getting-the-source) and that you have in vehicle --version ``` - This should print `0.11.0`. + This should print `0.11.1`. 1. Check if your installation of the `vehicle_lang` package was successful. @@ -917,11 +920,11 @@ The procedure to create a new release is: This creates the directory `dist` which contains "wheels", which are the binary distribution format for Python packages. If you're on macOS with an M1/M2 chipset, these look like: ``` - vehicle_lang-0.11.0-cp310-cp310-macosx_13_0_arm64.whl - vehicle_lang-0.11.0-cp37-cp37m-macosx_13_0_arm64.whl - vehicle_lang-0.11.0-cp39-cp39-macosx_13_0_arm64.whl - vehicle_lang-0.11.0-cp311-cp311-macosx_13_0_arm64.whl - vehicle_lang-0.11.0-cp38-cp38-macosx_13_0_arm64.whl + vehicle_lang-0.11.1-cp310-cp310-macosx_13_0_arm64.whl + vehicle_lang-0.11.1-cp37-cp37m-macosx_13_0_arm64.whl + vehicle_lang-0.11.1-cp39-cp39-macosx_13_0_arm64.whl + vehicle_lang-0.11.1-cp311-cp311-macosx_13_0_arm64.whl + vehicle_lang-0.11.1-cp38-cp38-macosx_13_0_arm64.whl ``` Run the following command to check each wheel's metadata: @@ -942,7 +945,7 @@ The procedure to create a new release is: The release will be at a URL like: - + [vehicle-lang/vehicle]: https://github.com/vehicle-lang/vehicle [GHC]: https://www.haskell.org/ghc/ diff --git a/ChangeLog.md b/ChangeLog.md index beecaa8f5..0a817b592 100644 --- a/ChangeLog.md +++ b/ChangeLog.md @@ -2,6 +2,10 @@ ## Version 0.12.0 +* Allow `@parameter`s to be used as network sizes. + +## Version 0.11.1 + * Fixed bug properties involving the comparison of abstract `Index` values would throw a `Something went wrong in query compilation` error. diff --git a/bumpver.toml b/bumpver.toml index 7091e0ee4..3eddaff99 100644 --- a/bumpver.toml +++ b/bumpver.toml @@ -1,5 +1,5 @@ [bumpver] -current_version = "v0.11.0" +current_version = "v0.11.1" version_pattern = "vMAJOR.MINOR.PATCH" commit_message = "Bump version {old_version} -> {new_version}" commit = true diff --git a/cabal.project.ghc-9.4.8 b/cabal.project.ghc-9.4.8 index 5a450ec5d..cf0fc4b5f 100644 --- a/cabal.project.ghc-9.4.8 +++ b/cabal.project.ghc-9.4.8 @@ -1,3 +1,4 @@ + -- Cabal project configuration file for GHC 9.4.8 -- -- See `cabal.project` for details. diff --git a/tasty-golden-executable/src/Test/Tasty/Golden/Executable/Runner.hs b/tasty-golden-executable/src/Test/Tasty/Golden/Executable/Runner.hs index cecfc1bc9..7ff51aa15 100644 --- a/tasty-golden-executable/src/Test/Tasty/Golden/Executable/Runner.hs +++ b/tasty-golden-executable/src/Test/Tasty/Golden/Executable/Runner.hs @@ -24,6 +24,7 @@ import Data.Functor ((<&>)) import Data.List qualified as List (findIndices, splitAt, uncons) import Data.Maybe (fromMaybe, mapMaybe) import Data.Proxy (Proxy (..)) +import Data.Set (Set) import Data.Set qualified as Set import Data.String (IsString (..)) import Data.Tagged (Tagged (..)) @@ -36,8 +37,8 @@ import Data.Traversable (for) import General.Extra.Diff (isBoth, mapDiff) import General.Extra.File (createDirectoryRecursive, listFilesRecursive, writeFileChanged) import General.Extra.NonEmpty qualified as NonEmpty (appendList, prependList, singleton) -import System.Directory (copyFile, doesFileExist, removeFile) -import System.FilePath (isAbsolute, isExtensionOf, makeRelative, stripExtension, (<.>), ()) +import System.Directory (copyFile, createDirectoryIfMissing, doesFileExist, removeFile) +import System.FilePath (isAbsolute, isExtensionOf, makeRelative, stripExtension, takeDirectory, takeExtension, (<.>), ()) import System.IO (IOMode (..), hFileSize, withFile) import System.IO.Temp (withSystemTempDirectory) import System.Process (CreateProcess (..), readCreateProcessWithExitCode, shell) @@ -48,6 +49,7 @@ import Test.Tasty.Golden.Executable.TestSpec.Accept (Accept (..)) import Test.Tasty.Golden.Executable.TestSpec.External (AllowlistExternals (..)) import Test.Tasty.Golden.Executable.TestSpec.FilePattern (FilePattern, addExtension, asLiteral, glob, match) import Test.Tasty.Golden.Executable.TestSpec.Ignore (Ignore (..), IgnoreFiles (..), IgnoreLines (..)) +import Test.Tasty.Golden.Executable.TestSpec.SizeOnly (SizeOnlyExtensions, toSizeOnlyExtensionsSet) import Test.Tasty.Golden.Executable.TestSpec.TextPattern (strikeOut) import Test.Tasty.Golden.Executable.TestSpecs (TestSpecs (..), readTestSpecsFile, testSpecsFileName, writeTestSpecsFile) import Test.Tasty.Options (OptionDescription (..), OptionSet, lookupOption) @@ -86,13 +88,14 @@ instance IsTest TestSpec where -- Diff stderr diffStderr maybeLooseEq stderr -- Diff produced files - diffTestProduced maybeLooseEq testSpecProduces (ignoreFiles <> lookupOption options) + diffTestProduced maybeLooseEq testSpecProduces (ignoreFiles <> lookupOption options) (lookupOption options) testOptions :: Tagged TestSpec [OptionDescription] testOptions = return [ Option (Proxy :: Proxy Accept), Option (Proxy :: Proxy AllowlistExternals), + Option (Proxy :: Proxy SizeOnlyExtensions), Option (Proxy :: Proxy IgnoreFiles), Option (Proxy :: Proxy IgnoreLines) ] @@ -196,7 +199,7 @@ runTestRun cmd = TestT $ do diffStdout :: Maybe (Text -> Text -> Bool) -> Lazy.Text -> TestIO () diffStdout maybeLooseEq actual = do golden <- readGoldenStdout - lift $ diffText (shortCircuitWithEq maybeLooseEq) golden actual + lift $ diffText (shortCircuitWithEq maybeLooseEq) Nothing golden actual -- | Update the standard output golden file. acceptStdout :: Lazy.Text -> TestIO () @@ -229,7 +232,7 @@ writeGoldenStdout contents = TestT $ do diffStderr :: Maybe (Text -> Text -> Bool) -> Lazy.Text -> TestIO () diffStderr maybeLooseEq actual = do golden <- readGoldenStderr - lift $ diffText (shortCircuitWithEq maybeLooseEq) golden actual + lift $ diffText (shortCircuitWithEq maybeLooseEq) Nothing golden actual -- | Update the standard error golden file. acceptStderr :: Lazy.Text -> TestIO () @@ -259,10 +262,11 @@ writeGoldenStderr contents = TestT $ do -- | Compare the files produced by the test. -- -- NOTE: The loose equality must extend equality. -diffTestProduced :: Maybe (Text -> Text -> Bool) -> [FilePattern] -> IgnoreFiles -> TestIO () -diffTestProduced maybeLooseEq testProduces (IgnoreFiles testIgnores) = do +diffTestProduced :: Maybe (Text -> Text -> Bool) -> [FilePattern] -> IgnoreFiles -> SizeOnlyExtensions -> TestIO () +diffTestProduced maybeLooseEq testProduces (IgnoreFiles testIgnores) sizeOnlyExtensions = do TestEnvironment {testDirectory, tempDirectory} <- getTestEnvironment let shortCircuitLooseEq = shortCircuitWithEq maybeLooseEq + let sizeOnlyExtensionsSet = toSizeOnlyExtensionsSet sizeOnlyExtensions -- Find the golden and actual files: goldenFiles <- findTestProducesGolden testProduces actualFiles <- findTestProducesActual testIgnores @@ -279,13 +283,13 @@ diffTestProduced maybeLooseEq testProduces (IgnoreFiles testIgnores) = do let expectedFilesNotProduced = Set.toAscList $ Set.difference goldenFileSet actualFileSet for_ expectedFilesNotProduced $ tell . Just . expectedFileNotProduced -- Test for files which were produced but not expected: - let producedFilesNotExpected = Set.toAscList $ Set.difference goldenFileSet actualFileSet + let producedFilesNotExpected = Set.toAscList $ Set.difference actualFileSet goldenFileSet for_ producedFilesNotExpected $ tell . Just . producedFileNotExpected -- Diff the files which were produced and expected: for_ (Set.toAscList $ Set.intersection goldenFileSet actualFileSet) $ \file -> do let goldenFile = testDirectory file <.> "golden" let actualFile = tempDirectory file - catch (lift $ lift $ diffFile shortCircuitLooseEq goldenFile actualFile) $ \diff -> + catch (lift $ lift $ diffFile shortCircuitLooseEq sizeOnlyExtensionsSet goldenFile actualFile) $ \diff -> tell $ Just $ producedAndExpectedDiffer actualFile diff -- If errors were raised, throw them. @@ -410,7 +414,7 @@ acceptTestProduced testProduces (IgnoreFiles testIgnores) = do when goldenFileExists $ removeFile (testDirectory goldenFile) -- Copy the new .golden files: - lift $ + lift $ do for_ actualFilesToCopy $ \actualFile -> do let goldenFile = actualFile <.> ".golden" goldenFileExists <- doesFileExist (testDirectory goldenFile) @@ -418,7 +422,9 @@ acceptTestProduced testProduces (IgnoreFiles testIgnores) = do then do actualFileContents <- TextIO.readFile (tempDirectory actualFile) writeFileChanged (testDirectory goldenFile) actualFileContents - else do copyFile (tempDirectory actualFile) (testDirectory actualFile <.> ".golden") + else do + createDirectoryIfMissing True (takeDirectory (testDirectory actualFile)) + copyFile (tempDirectory actualFile) (testDirectory actualFile <.> ".golden") return () -- | Find the actual files produced by the test command. @@ -485,23 +491,28 @@ fileSizeCutOffBytes = 100000 -- | Compare two files. -- -- NOTE: The loose equality must extend equality. -diffFile :: (Text -> Text -> Bool) -> FilePath -> FilePath -> IO () -diffFile eq golden actual = do +diffFile :: (Text -> Text -> Bool) -> Set String -> FilePath -> FilePath -> IO () +diffFile eq sizeOnlyExtensions golden actual = do withFile golden ReadMode $ \goldenHandle -> do goldenSize <- hFileSize goldenHandle goldenContents <- LazyIO.hGetContents goldenHandle withFile actual ReadMode $ \actualHandle -> do actualSize <- hFileSize actualHandle + let sizeDiff = makeSizeOnlyDiff goldenSize actualSize + let sizeOnly = Set.member (takeExtension actual) sizeOnlyExtensions + let maybeSizeDiff = if sizeOnly then Just sizeDiff else Nothing actualContents <- LazyIO.hGetContents actualHandle if max goldenSize actualSize < fileSizeCutOffBytes - then diffText eq goldenContents actualContents - else when (goldenContents /= actualContents) $ throw (NoDiff "file too big") + then diffText eq maybeSizeDiff goldenContents actualContents + else + when (goldenContents /= actualContents) $ + throw (NoDiff ("file too big to diff but contents not equal. " <> sizeDiff)) -- | Compare two texts. -- -- NOTE: The loose equality must extend equality. -diffText :: (Text -> Text -> Bool) -> Lazy.Text -> Lazy.Text -> IO () -diffText eq golden actual = do +diffText :: (Text -> Text -> Bool) -> Maybe String -> Lazy.Text -> Lazy.Text -> IO () +diffText eq maybeSizeDiff golden actual = do -- Lazily split the golden and actual texts into lines let goldenLines = Lazy.toStrict <$> Lazy.lines golden let actualLines = Lazy.toStrict <$> Lazy.lines actual @@ -510,7 +521,9 @@ diffText eq golden actual = do -- If both files are the same, the diff should be just "Both": unless (all isBoth groupedDiff) $ throw $ - Diff (ppDiff $ mapDiff (Text.unpack <$>) <$> groupedDiff) + Diff $ case maybeSizeDiff of + Nothing -> ppDiff $ mapDiff (Text.unpack <$>) <$> groupedDiff + Just sizeDiff -> sizeDiff return () -- | Make a loose equality which ignores text matching the provided text patterns. @@ -522,3 +535,12 @@ makeLooseEq (IgnoreLines patterns) golden actual = strikeOutAll golden == strike -- | Make a loose equality which short-circuits using equality. shortCircuitWithEq :: (Eq a) => Maybe (a -> a -> Bool) -> a -> a -> Bool shortCircuitWithEq maybeEq x y = x == y || maybe False (\eq -> x `eq` y) maybeEq + +makeSizeOnlyDiff :: Integer -> Integer -> String +makeSizeOnlyDiff goldenSize actualSize = + "< expected " + <> show goldenSize + <> " bytes\n" + <> "> produced " + <> show actualSize + <> " bytes" diff --git a/tasty-golden-executable/src/Test/Tasty/Golden/Executable/TestSpec/SizeOnly.hs b/tasty-golden-executable/src/Test/Tasty/Golden/Executable/TestSpec/SizeOnly.hs new file mode 100644 index 000000000..a67af482e --- /dev/null +++ b/tasty-golden-executable/src/Test/Tasty/Golden/Executable/TestSpec/SizeOnly.hs @@ -0,0 +1,64 @@ +{-# LANGUAGE GeneralizedNewtypeDeriving #-} + +module Test.Tasty.Golden.Executable.TestSpec.SizeOnly + ( SizeOnlyExtension (..), + SizeOnlyExtensions (..), + toSizeOnlyExtensionsSet, + ) +where + +import Data.Aeson.Types (FromJSON (..), Parser, ToJSON (..), Value, typeMismatch) +import Data.Aeson.Types qualified as Value (Value (..)) +import Data.Data (Typeable) +import Data.Set (Set) +import Data.Set qualified as Set (fromList) +import Data.String (IsString (..)) +import Data.Tagged (Tagged) +import Data.Text qualified as Text +import Test.Tasty.Options (IsOption (..), safeRead) + +-- | Extension for which only diffs should show the size. +newtype SizeOnlyExtension = SizeOnlyExtension {extension :: FilePath} + deriving (Eq, Ord, Typeable) + +instance Show SizeOnlyExtension where + show :: SizeOnlyExtension -> String + show (SizeOnlyExtension programName) = programName + +instance Read SizeOnlyExtension where + readsPrec :: Int -> ReadS SizeOnlyExtension + readsPrec _prec programName = [(SizeOnlyExtension programName, "")] + +instance IsString SizeOnlyExtension where + fromString :: String -> SizeOnlyExtension + fromString = SizeOnlyExtension + +instance FromJSON SizeOnlyExtension where + parseJSON :: Value -> Parser SizeOnlyExtension + parseJSON (Value.String name) = return $ SizeOnlyExtension (Text.unpack name) + parseJSON value = typeMismatch "String" value + +instance ToJSON SizeOnlyExtension where + toJSON :: SizeOnlyExtension -> Value + toJSON = toJSON . extension + +newtype SizeOnlyExtensions = SizeOnlyExtensions [SizeOnlyExtension] + deriving (Eq, Ord, Show, Typeable, Semigroup, Monoid) + +instance IsOption SizeOnlyExtensions where + defaultValue :: SizeOnlyExtensions + defaultValue = mempty + + parseValue :: String -> Maybe SizeOnlyExtensions + parseValue input = SizeOnlyExtensions <$> traverse safeRead names + where + names = Text.unpack . Text.strip <$> Text.splitOn "," (Text.pack input) + + optionName :: Tagged SizeOnlyExtensions String + optionName = return "sizeOnly" + + optionHelp :: Tagged SizeOnlyExtensions String + optionHelp = return "A list of file extensions for which diffs should only display the sizes of the old and new files." + +toSizeOnlyExtensionsSet :: SizeOnlyExtensions -> Set String +toSizeOnlyExtensionsSet (SizeOnlyExtensions exts) = Set.fromList (fmap extension exts) diff --git a/tasty-golden-executable/tasty-golden-executable.cabal b/tasty-golden-executable/tasty-golden-executable.cabal index 3e1394ef7..37e276930 100644 --- a/tasty-golden-executable/tasty-golden-executable.cabal +++ b/tasty-golden-executable/tasty-golden-executable.cabal @@ -44,6 +44,7 @@ library Test.Tasty.Golden.Executable.TestSpec.External Test.Tasty.Golden.Executable.TestSpec.FilePattern Test.Tasty.Golden.Executable.TestSpec.Ignore + Test.Tasty.Golden.Executable.TestSpec.SizeOnly Test.Tasty.Golden.Executable.TestSpec.TextPattern Test.Tasty.Golden.Executable.TestSpec.Timeout Test.Tasty.Golden.Executable.TestSpecs diff --git a/tools/latex-minted/Dockerfile b/tools/latex-minted/Dockerfile new file mode 100644 index 000000000..e8c9d6219 --- /dev/null +++ b/tools/latex-minted/Dockerfile @@ -0,0 +1,33 @@ +# To build: docker build -o . . +FROM texlive/texlive:latest AS build-stage + +# Install vehicle-lang +RUN <=4.6,<5", "astunparse; python_version<'3.9'", ] [project.optional-dependencies] -test = ["pytest >=7.1,<8", "packaging >=23", "pygments >=2.14, <3"] +test = ["pytest >=7.1,<9", "packaging >=23", "pygments >=2.14, <3"] mypy = ["types_setuptools >=45", "types_pygments >=2.14,<3"] pygments = ["pygments >=2.14,<3"] tensorflow = [ @@ -95,9 +95,9 @@ version = { attr = "vehicle_lang._version.VERSION" } legacy_tox_ini = """ [tox] min_version = 4 -env_list = py{37,38,39,310,311}-{lin,mac,win} +env_list = py{37,38,39,310,311,312}-{lin,mac,win} -[testenv:py{37,38,39,310,311}-{lin,mac,win}] +[testenv:py{37,38,39,310,311,312}-{lin,mac,win}] package = external package_env = build-{env_name} platform = @@ -109,11 +109,11 @@ allowlist_externals = extras = test pygments - py38,py39,py310,py311: tensorflow + py38,py39,py310,py311,py312: tensorflow commands = {env_python} -m pytest {posargs} -[testenv:build-py{37,38,39,310,311}-{lin,mac,win}] +[testenv:build-py{37,38,39,310,311,312}-{lin,mac,win}] deps = build auditwheel; sys_platform == 'linux' @@ -129,16 +129,19 @@ package_glob = py39-lin: {env:dist_dir}{/}*cp39*manylinux*.whl py310-lin: {env:dist_dir}{/}*cp310*manylinux*.whl py311-lin: {env:dist_dir}{/}*cp311*manylinux*.whl + py312-lin: {env:dist_dir}{/}*cp312*manylinux*.whl py37-mac: {env:dist_dir}{/}*cp37*macosx*.whl py38-mac: {env:dist_dir}{/}*cp38*macosx*.whl py39-mac: {env:dist_dir}{/}*cp39*macosx*.whl py310-mac: {env:dist_dir}{/}*cp310*macosx*.whl py311-mac: {env:dist_dir}{/}*cp311*macosx*.whl + py312-mac: {env:dist_dir}{/}*cp312*macosx*.whl py37-win: {env:dist_dir}{/}*cp37*win*.whl py38-win: {env:dist_dir}{/}*cp38*win*.whl py39-win: {env:dist_dir}{/}*cp39*win*.whl py310-win: {env:dist_dir}{/}*cp310*win*.whl py311-win: {env:dist_dir}{/}*cp311*win*.whl + py312-win: {env:dist_dir}{/}*cp312*win*.whl allowlist_externals = sh commands = diff --git a/vehicle-python/requirements-ci.txt b/vehicle-python/requirements-ci.txt index b0db82c0b..dd7f4d0b0 100644 --- a/vehicle-python/requirements-ci.txt +++ b/vehicle-python/requirements-ci.txt @@ -2,4 +2,4 @@ auditwheel >=5.3.0, <6; sys_platform == 'linux' build >=0.10.0, <1.1 delocate >=0.10.4, <0.11; sys_platform == 'darwin' delvewheel >=1.3.5, <2; sys_platform == 'win32' -pytest >=7.2.2, <8 +pytest >=7.2.2, <9 diff --git a/vehicle-python/src/VehiclePythonBinding.hs b/vehicle-python/src/VehiclePythonBinding.hs index c4431e9c1..f026cfe7c 100644 --- a/vehicle-python/src/VehiclePythonBinding.hs +++ b/vehicle-python/src/VehiclePythonBinding.hs @@ -1,13 +1,25 @@ {-# LANGUAGE ForeignFunctionInterface #-} -{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -Wno-orphans #-} module VehiclePythonBinding where -import Foreign.C.String (CString, peekCString) +import Data.ByteString (useAsCString) +import Data.Text (Text) +import Data.Text.Encoding (encodeUtf8) +import Foreign.C.String (CString, peekCString, withCString) import Foreign.C.Types (CInt (..)) import Foreign.Marshal.Array (peekArray) import Foreign.Ptr (Ptr) import Vehicle (mainWithArgsAndExitCode) +import Vehicle.Prelude (MonadStdIO (..)) + +foreign import ccall _unsafe_python_write_stdout :: CString -> IO () + +foreign import ccall _unsafe_python_write_stderr :: CString -> IO () + +instance MonadStdIO IO where + writeStdout str = encodeUtf8 str `useAsCString` _unsafe_python_write_stdout + writeStderr str = encodeUtf8 str `useAsCString` _unsafe_python_write_stderr _unsafe_vehicle_main :: CInt -> Ptr CString -> IO CInt _unsafe_vehicle_main argc argv = do diff --git a/vehicle-python/src/vehicle_lang/_version.py b/vehicle-python/src/vehicle_lang/_version.py index 7e17de778..7d1d9658a 100644 --- a/vehicle-python/src/vehicle_lang/_version.py +++ b/vehicle-python/src/vehicle_lang/_version.py @@ -1 +1 @@ -VERSION: str = "0.11.0" +VERSION: str = "0.11.1" diff --git a/vehicle-python/src/vehicle_lang/ast/__init__.py b/vehicle-python/src/vehicle_lang/ast/__init__.py index 26d39fb03..c974c8500 100644 --- a/vehicle-python/src/vehicle_lang/ast/__init__.py +++ b/vehicle-python/src/vehicle_lang/ast/__init__.py @@ -497,8 +497,7 @@ def __init__(self) -> None: raise TypeError("Cannot instantiate abstract class Declaration") @abstractmethod - def get_name(self) -> Name: - ... + def get_name(self) -> Name: ... @dataclass(frozen=True) diff --git a/vehicle-python/src/vehicle_lang/ast/_decode.py b/vehicle-python/src/vehicle_lang/ast/_decode.py index 15d0e197c..bc2836ce0 100644 --- a/vehicle-python/src/vehicle_lang/ast/_decode.py +++ b/vehicle-python/src/vehicle_lang/ast/_decode.py @@ -67,8 +67,7 @@ def decode( cls_origin: Any, cls_args: Tuple[Any, ...], value: JsonValue, - ) -> _T: - ... + ) -> _T: ... class TaggedObjectDecoder(Decoder[_T]): diff --git a/vehicle-python/src/vehicle_lang/binding.i b/vehicle-python/src/vehicle_lang/binding.i index afdf81d33..5cb251442 100644 --- a/vehicle-python/src/vehicle_lang/binding.i +++ b/vehicle-python/src/vehicle_lang/binding.i @@ -13,6 +13,14 @@ void _unsafe_vehicle_free() { void hs_exit(); } + +void _unsafe_python_write_stdout(const char * str) { + PySys_FormatStdout("%s", str); +} + +void _unsafe_python_write_stderr(const char * str) { + PySys_FormatStderr("%s", str); +} %} %typemap(in) (int argc, char **argv) { diff --git a/vehicle-python/src/vehicle_lang/compile/_collections.py b/vehicle-python/src/vehicle_lang/compile/_collections.py index 1c4a98f2b..b63569712 100644 --- a/vehicle-python/src/vehicle_lang/compile/_collections.py +++ b/vehicle-python/src/vehicle_lang/compile/_collections.py @@ -12,8 +12,7 @@ class SupportsList(Iterable[_T_co], Protocol[_T_co]): @runtime_checkable class Subscriptable(Protocol[_T_co]): - def __getitem__(self, index: int) -> _T_co: - ... + def __getitem__(self, index: int) -> _T_co: ... @runtime_checkable diff --git a/vehicle-python/src/vehicle_lang/compile/_numeric.py b/vehicle-python/src/vehicle_lang/compile/_numeric.py index 83d3934fe..31fd6bd3e 100644 --- a/vehicle-python/src/vehicle_lang/compile/_numeric.py +++ b/vehicle-python/src/vehicle_lang/compile/_numeric.py @@ -3,51 +3,43 @@ @runtime_checkable class SupportsDunderLT(Protocol): - def __lt__(self, other: Self) -> bool: - ... + def __lt__(self, other: Self) -> bool: ... @runtime_checkable class SupportsDunderGT(Protocol): - def __gt__(self, other: Self) -> bool: - ... + def __gt__(self, other: Self) -> bool: ... @runtime_checkable class SupportsDunderLE(Protocol): - def __le__(self, other: Self) -> bool: - ... + def __le__(self, other: Self) -> bool: ... @runtime_checkable class SupportsDunderGE(Protocol): - def __ge__(self, other: Self) -> bool: - ... + def __ge__(self, other: Self) -> bool: ... @runtime_checkable class SupportsRichComparison( SupportsDunderLT, SupportsDunderGT, SupportsDunderLE, SupportsDunderGE, Protocol -): - ... +): ... @runtime_checkable class SupportsAbs(Protocol): - def __abs__(self: Self) -> Self: - ... + def __abs__(self: Self) -> Self: ... @runtime_checkable class SupportsAdd(Protocol): - def __add__(self: Self, other: Self) -> Self: - ... + def __add__(self: Self, other: Self) -> Self: ... @runtime_checkable class SupportsMul(Protocol): - def __mul__(self: Self, other: Self) -> Self: - ... + def __mul__(self: Self, other: Self) -> Self: ... @runtime_checkable @@ -58,20 +50,17 @@ class SupportsNat( SupportsMul, Protocol, ): - def __int__(self: Self) -> int: - ... + def __int__(self: Self) -> int: ... @runtime_checkable class SupportsNeg(Protocol): - def __neg__(self: Self) -> Self: - ... + def __neg__(self: Self) -> Self: ... @runtime_checkable class SupportsSub(Protocol): - def __sub__(self: Self, other: Self) -> Self: - ... + def __sub__(self: Self, other: Self) -> Self: ... @runtime_checkable @@ -80,20 +69,17 @@ class SupportsInt( SupportsNeg, SupportsSub, Protocol, -): - ... +): ... @runtime_checkable class SupportsDiv(Protocol): - def __truediv__(self: Self, other: Self) -> Self: - ... + def __truediv__(self: Self, other: Self) -> Self: ... @runtime_checkable class SupportsPow2(Protocol): - def __pow__(self: Self, other: int) -> Self: - ... + def __pow__(self: Self, other: int) -> Self: ... @runtime_checkable @@ -103,5 +89,4 @@ class SupportsRat( SupportsPow2, Protocol, ): - def __float__(self: Self) -> float: - ... + def __float__(self: Self) -> float: ... diff --git a/vehicle-python/src/vehicle_lang/compile/abc.py b/vehicle-python/src/vehicle_lang/compile/abc.py index 4288cee8e..5448d06a0 100644 --- a/vehicle-python/src/vehicle_lang/compile/abc.py +++ b/vehicle-python/src/vehicle_lang/compile/abc.py @@ -57,8 +57,7 @@ def And(self, x: bool, y: bool) -> bool: return x and y @abstractmethod - def AtVector(self, vector: SupportsVector[_T], index: int) -> _T: - ... + def AtVector(self, vector: SupportsVector[_T], index: int) -> _T: ... def Bool(self, value: bool) -> bool: assert isinstance(value, bool), f"Expected bool, found {value}" @@ -108,8 +107,7 @@ def FoldList( @abstractmethod def FoldVector( self, function: Callable[[_S, _T], _T], initial: _T, vector: SupportsVector[_S] - ) -> _T: - ... + ) -> _T: ... def Forall( self, name: str, context: Dict[str, Any], predicate: Callable[[_T], bool] @@ -171,8 +169,7 @@ def Indices(self, upto: int) -> SupportsVector[int]: return self.Vector(*range(0, upto)) @abstractmethod - def Int(self, value: SupportsInt) -> _SupportsInt: - ... + def Int(self, value: SupportsInt) -> _SupportsInt: ... def LeIndex(self, x: int, y: int) -> bool: assert isinstance(x, int), f"Expected int, found {x}" @@ -224,8 +221,7 @@ def MapList( @abstractmethod def MapVector( self, function: Callable[[_S], _T], vector: SupportsVector[_S] - ) -> SupportsVector[_T]: - ... + ) -> SupportsVector[_T]: ... def MaxRat(self, x: _SupportsRat, y: _SupportsRat) -> _SupportsRat: assert isinstance(x, _numeric.SupportsRat), f"Expected Rat, found {x}" @@ -253,8 +249,7 @@ def MulRat(self, x: _SupportsRat, y: _SupportsRat) -> _SupportsRat: return x * y @abstractmethod - def Nat(self, value: SupportsInt) -> _SupportsNat: - ... + def Nat(self, value: SupportsInt) -> _SupportsNat: ... def NeIndex(self, x: int, y: int) -> bool: return self.Not(self.EqIndex(x, y)) @@ -307,8 +302,7 @@ def PowRat(self, x: _SupportsRat, y: _SupportsInt) -> _SupportsRat: return x ** y.__int__() @abstractmethod - def Rat(self, value: SupportsFloat) -> _SupportsRat: - ... + def Rat(self, value: SupportsFloat) -> _SupportsRat: ... def SubInt(self, x: _SupportsInt, y: _SupportsInt) -> _SupportsInt: assert isinstance(x, _numeric.SupportsInt), f"Expected Int, found {x}" @@ -324,8 +318,7 @@ def Unit(self) -> Tuple[()]: return () @abstractmethod - def Vector(self, *values: _T) -> SupportsVector[_T]: - ... + def Vector(self, *values: _T) -> SupportsVector[_T]: ... @abstractmethod def ZipWithVector( @@ -333,8 +326,7 @@ def ZipWithVector( function: Callable[[_S, _T], _U], vector1: SupportsVector[_S], vector2: SupportsVector[_T], - ) -> SupportsVector[_U]: - ... + ) -> SupportsVector[_U]: ... AnyBuiltins: TypeAlias = ABCBuiltins[Any, Any, Any] @@ -351,16 +343,13 @@ def ZipWithVector( class Translation(Generic[_Program, _Declaration, _Expression], metaclass=ABCMeta): @abstractmethod - def translate_program(self, program: vcl.Program) -> _Program: - ... + def translate_program(self, program: vcl.Program) -> _Program: ... @abstractmethod - def translate_declaration(self, declaration: vcl.Declaration) -> _Declaration: - ... + def translate_declaration(self, declaration: vcl.Declaration) -> _Declaration: ... @abstractmethod - def translate_expression(self, expression: vcl.Expression) -> _Expression: - ... + def translate_expression(self, expression: vcl.Expression) -> _Expression: ... class ABCTranslation(Translation[_Program, _Declaration, _Expression]): @@ -371,8 +360,7 @@ def translate_program(self, program: vcl.Program) -> _Program: raise NotImplementedError(type(program).__name__) @abstractmethod - def translate_Main(self, program: vcl.Main) -> _Program: - ... + def translate_Main(self, program: vcl.Main) -> _Program: ... @override def translate_declaration(self, declaration: vcl.Declaration) -> _Declaration: @@ -383,12 +371,10 @@ def translate_declaration(self, declaration: vcl.Declaration) -> _Declaration: raise NotImplementedError(type(declaration).__name__) @abstractmethod - def translate_DefFunction(self, declaration: vcl.DefFunction) -> _Declaration: - ... + def translate_DefFunction(self, declaration: vcl.DefFunction) -> _Declaration: ... @abstractmethod - def translate_DefPostulate(self, declaration: vcl.DefPostulate) -> _Declaration: - ... + def translate_DefPostulate(self, declaration: vcl.DefPostulate) -> _Declaration: ... @override def translate_expression(self, expression: vcl.Expression) -> _Expression: @@ -413,24 +399,19 @@ def translate_expression(self, expression: vcl.Expression) -> _Expression: raise NotImplementedError(type(expression).__name__) @abstractmethod - def translate_App(self, expression: vcl.App) -> _Expression: - ... + def translate_App(self, expression: vcl.App) -> _Expression: ... @abstractmethod - def translate_BoundVar(self, expression: vcl.BoundVar) -> _Expression: - ... + def translate_BoundVar(self, expression: vcl.BoundVar) -> _Expression: ... @abstractmethod - def translate_Builtin(self, expression: vcl.Builtin) -> _Expression: - ... + def translate_Builtin(self, expression: vcl.Builtin) -> _Expression: ... @abstractmethod - def translate_FreeVar(self, expression: vcl.FreeVar) -> _Expression: - ... + def translate_FreeVar(self, expression: vcl.FreeVar) -> _Expression: ... @abstractmethod - def translate_Lam(self, expression: vcl.Lam) -> _Expression: - ... + def translate_Lam(self, expression: vcl.Lam) -> _Expression: ... def translate_Let(self, expression: vcl.Let) -> _Expression: return self.translate_expression( @@ -446,13 +427,10 @@ def translate_Let(self, expression: vcl.Let) -> _Expression: ) @abstractmethod - def translate_PartialApp(self, expression: vcl.PartialApp) -> _Expression: - ... + def translate_PartialApp(self, expression: vcl.PartialApp) -> _Expression: ... @abstractmethod - def translate_Pi(self, expression: vcl.Pi) -> _Expression: - ... + def translate_Pi(self, expression: vcl.Pi) -> _Expression: ... @abstractmethod - def translate_Universe(self, expression: vcl.Universe) -> _Expression: - ... + def translate_Universe(self, expression: vcl.Universe) -> _Expression: ... diff --git a/vehicle-python/src/vehicle_lang/session/__init__.py b/vehicle-python/src/vehicle_lang/session/__init__.py index e70ac05d8..a96fc93d4 100644 --- a/vehicle-python/src/vehicle_lang/session/__init__.py +++ b/vehicle-python/src/vehicle_lang/session/__init__.py @@ -1,6 +1,7 @@ import atexit +import io import sys -from contextlib import AbstractContextManager +from contextlib import AbstractContextManager, redirect_stderr, redirect_stdout from types import TracebackType from typing import TYPE_CHECKING, ClassVar, List, Optional, Sequence, Tuple, Type @@ -77,16 +78,21 @@ def check_output( self, args: Sequence[str], ) -> Tuple[int, Optional[str], Optional[str], Optional[str]]: - with temporary_files("out", "err", "log", prefix="vehicle") as (out, err, log): - exitCode = self.check_call( - [ - f"--redirect-stdout={out}", - f"--redirect-stderr={err}", - f"--redirect-logs={log}", - *args, - ] - ) - return (exitCode, out.read_text(), err.read_text(), log.read_text()) + with redirect_stdout(io.StringIO()) as out: + with redirect_stderr(io.StringIO()) as err: + with temporary_files("log", prefix="vehicle") as (log,): + exitCode = self.check_call( + [ + f"--redirect-logs={log}", + *args, + ] + ) + return ( + exitCode, + out.getvalue() or None, + err.getvalue() or None, + log.read_text(), + ) def close(self) -> None: if not self.closed: diff --git a/vehicle-python/src/vehicle_lang/typing.py b/vehicle-python/src/vehicle_lang/typing.py index 63d36693d..0c22522de 100644 --- a/vehicle-python/src/vehicle_lang/typing.py +++ b/vehicle-python/src/vehicle_lang/typing.py @@ -49,8 +49,7 @@ class Target(Protocol): """ @property - def _vehicle_option_name(self) -> str: - ... + def _vehicle_option_name(self) -> str: ... class Explicit(Enum): diff --git a/vehicle-python/vehicle-python-binding.cabal b/vehicle-python/vehicle-python-binding.cabal index 565e35ff5..ecb150613 100644 --- a/vehicle-python/vehicle-python-binding.cabal +++ b/vehicle-python/vehicle-python-binding.cabal @@ -1,6 +1,6 @@ cabal-version: 3.0 name: vehicle-python-binding -version: 0.11.0 +version: 0.11.1 description: Please see the README on GitHub at @@ -32,6 +32,12 @@ foreign-library _binding import: warnings type: native-shared + -- 10-01-2024: + -- Add RTS options for compilation to dynamic library. + ghc-options: + -with-rtsopts="--install-signal-handlers=no" + -with-rtsopts="--install-seh-handlers=no" -with-rtsopts="-V0" + -- 01-04-2023: -- Standalone builds appear to work with macOS builds of GHC if os(osx) @@ -45,8 +51,10 @@ foreign-library _binding hs-source-dirs: src other-modules: VehiclePythonBinding build-depends: - , base >=4.7 && <5 - , optparse-applicative >=0.16 && <1 + , base + , bytestring + , optparse-applicative + , text , vehicle default-language: Haskell2010 diff --git a/vehicle-syntax/src/Vehicle/Syntax/AST/Arg.hs b/vehicle-syntax/src/Vehicle/Syntax/AST/Arg.hs index ac325a587..ad386593e 100644 --- a/vehicle-syntax/src/Vehicle/Syntax/AST/Arg.hs +++ b/vehicle-syntax/src/Vehicle/Syntax/AST/Arg.hs @@ -77,14 +77,14 @@ unpairArg (Arg p v r (x, y)) = (Arg p v r x, y) replaceArgExpr :: expr1 -> GenericArg expr2 -> GenericArg expr1 replaceArgExpr e = fmap (const e) -traverseNonInstanceArgExpr :: +traverseExplicitArgExpr :: (Monad m) => (expr -> m expr) -> GenericArg expr -> m (GenericArg expr) -traverseNonInstanceArgExpr f arg - | isInstance arg = return arg - | otherwise = traverse f arg +traverseExplicitArgExpr f arg + | isExplicit arg = traverse f arg + | otherwise = return arg argFromBinder :: GenericBinder expr -> expr -> GenericArg expr argFromBinder (Binder p i v r _) = Arg p v r diff --git a/vehicle-syntax/src/Vehicle/Syntax/AST/Expr.hs b/vehicle-syntax/src/Vehicle/Syntax/AST/Expr.hs index c3a0a0689..50d9d2048 100644 --- a/vehicle-syntax/src/Vehicle/Syntax/AST/Expr.hs +++ b/vehicle-syntax/src/Vehicle/Syntax/AST/Expr.hs @@ -22,6 +22,7 @@ module Vehicle.Syntax.AST.Expr -- * Utilities isTypeSynonym, + isPi, mkHole, normAppList, pattern TypeUniverse, @@ -193,6 +194,10 @@ isTypeSynonym = \case Pi _ _ res -> isTypeSynonym res _ -> False +isPi :: Type var builtin -> Bool +isPi Pi {} = True +isPi _ = False + pattern TypeUniverse :: Provenance -> Int -> Expr var builtin pattern TypeUniverse p l = Universe p (UniverseLevel l) diff --git a/vehicle-syntax/src/Vehicle/Syntax/AST/Prog.hs b/vehicle-syntax/src/Vehicle/Syntax/AST/Prog.hs index 74e87380d..7faee45e3 100644 --- a/vehicle-syntax/src/Vehicle/Syntax/AST/Prog.hs +++ b/vehicle-syntax/src/Vehicle/Syntax/AST/Prog.hs @@ -25,3 +25,9 @@ traverseDecls :: GenericProg expr1 -> m (GenericProg expr2) traverseDecls f (Main ds) = Main <$> traverse f ds + +filterDecls :: + (GenericDecl expr -> Bool) -> + GenericProg expr -> + GenericProg expr +filterDecls pred (Main ds) = Main (filter pred ds) diff --git a/vehicle-syntax/src/Vehicle/Syntax/Builtin/BasicOperations.hs b/vehicle-syntax/src/Vehicle/Syntax/Builtin/BasicOperations.hs index 14e610771..862d1460f 100644 --- a/vehicle-syntax/src/Vehicle/Syntax/Builtin/BasicOperations.hs +++ b/vehicle-syntax/src/Vehicle/Syntax/Builtin/BasicOperations.hs @@ -7,6 +7,7 @@ module Vehicle.Syntax.Builtin.BasicOperations OrderOp (..), orderOp, orderOpName, + Strictness (..), isStrict, flipStrictness, flipOrder, @@ -16,7 +17,7 @@ module Vehicle.Syntax.Builtin.BasicOperations where import Control.DeepSeq (NFData (..)) -import Data.Aeson (ToJSON) +import Data.Aeson (FromJSON, ToJSON) import Data.Aeson.Types (ToJSON (..)) import Data.Hashable (Hashable (..)) import Data.Serialize (Serialize) @@ -129,6 +130,18 @@ flipOrder = \case chainable :: OrderOp -> OrderOp -> Bool chainable e1 e2 = e1 == e2 || e1 == flipStrictness e2 +-------------------------------------------------------------------------------- +-- Strictness + +data Strictness + = Strict + | NonStrict + deriving (Show, Eq, Ord, Generic) + +instance ToJSON Strictness + +instance FromJSON Strictness + -------------------------------------------------------------------------------- -- Quantifiers diff --git a/vehicle-syntax/vehicle-syntax.cabal b/vehicle-syntax/vehicle-syntax.cabal index 3efa86bfc..7d1f2a1d1 100644 --- a/vehicle-syntax/vehicle-syntax.cabal +++ b/vehicle-syntax/vehicle-syntax.cabal @@ -1,6 +1,6 @@ cabal-version: 3.0 name: vehicle-syntax -version: 0.11.0 +version: 0.11.1 description: Please see the README on GitHub at diff --git a/vehicle/.hlint.yaml b/vehicle/.hlint.yaml index a8831f31f..187d58b0e 100644 --- a/vehicle/.hlint.yaml +++ b/vehicle/.hlint.yaml @@ -10,5 +10,31 @@ - ignore: { name: Redundant return } - ignore: { name: Avoid lambda } - ignore: { name: Redundant <&> } -# To generate a suitable file for HLint do: -# $ hlint --default > .hlint.yaml + +# Exclude standard IO functions +- functions: + - { + name: + [ + Data.Text.IO.putStrLn, + Prelude.putStrLn, + Prelude.stderr, + Prelude.stdout, + System.IO.IO, + System.IO.putStrLn, + System.IO.stderr, + System.IO.stdout, + ], + within: + [ + Main, + Vehicle.Debug, + Vehicle.Prelude.IO, + Vehicle.Syntax.Internal.Test, + Vehicle.Syntax.Internal.ErrM, + Vehicle.Syntax.Internal.Abs, + Vehicle.Syntax.External.Test, + Vehicle.Syntax.External.ErrM, + Vehicle.Syntax.External.Abs, + ], + } diff --git a/vehicle/app/Main.hs b/vehicle/app/Main.hs index 4c1c0b790..f8b80d406 100644 --- a/vehicle/app/Main.hs +++ b/vehicle/app/Main.hs @@ -1,8 +1,15 @@ {-# LANGUAGE CPP #-} +{-# OPTIONS_GHC -Wno-orphans #-} module Main where -import Vehicle qualified (main) +import Data.Text (Text) +import Data.Text.IO qualified as TextIO +import System.Environment (getArgs) +import System.Exit (ExitCode (..), exitWith) +import System.IO (stderr) +import Vehicle (mainWithArgsAndExitCode) +import Vehicle.Prelude (MonadStdIO (..)) #ifdef ghcDebug import GHC.Debug.Stub (withGhcDebug) @@ -12,9 +19,37 @@ import GHC.Debug.Stub (withGhcDebug) -- Main function with ghc-debug instrumentation #ifdef ghcDebug -main :: IO () -main = withGhcDebug Vehicle.main +{-# INLINE maybeWithGhcDebug #-} +maybeWithGhcDebug :: IO () -> IO () +maybeWithGhcDebug = withGhcDebug #else -main :: IO () -main = Vehicle.main +{-# INLINE maybeWithGhcDebug #-} +maybeWithGhcDebug :: IO () -> IO () +maybeWithGhcDebug = id #endif + +instance MonadStdIO IO where + {-# INLINE writeStdout #-} + writeStdout :: Text -> IO () + writeStdout = TextIO.putStr + {-# INLINE writeStderr #-} + writeStderr :: Text -> IO () + writeStderr = TextIO.hPutStr stderr + {-# INLINE writeStdoutLn #-} + writeStdoutLn :: Text -> IO () + writeStdoutLn = TextIO.putStrLn + {-# INLINE writeStderrLn #-} + writeStderrLn :: Text -> IO () + writeStderrLn = TextIO.hPutStrLn stderr + +main :: IO () +main = + maybeWithGhcDebug $ do + args <- getArgs + exitCode <- mainWithArgsAndExitCode args + exitWith (toExitCode exitCode) + where + toExitCode :: Int -> ExitCode + toExitCode exitCode + | exitCode == 0 = ExitSuccess + | otherwise = ExitFailure exitCode diff --git a/vehicle/lib/std.vcl b/vehicle/lib/std.vcl index 641024795..6cb7c6bcc 100644 --- a/vehicle/lib/std.vcl +++ b/vehicle/lib/std.vcl @@ -1,4 +1,11 @@ -------------------------------------------------------------------------------- +-------------------------------------------------------------------------------- +-- Bool +-------------------------------------------------------------------------------- + +notBoolOp2 : (A -> B -> Bool) -> (A -> B -> Bool) +notBoolOp2 f x y = not (f x y) + +-------------------------------------------------------------------------------- -- List -------------------------------------------------------------------------------- diff --git a/vehicle/src/Vehicle.hs b/vehicle/src/Vehicle.hs index 71cdb1d65..d91744595 100644 --- a/vehicle/src/Vehicle.hs +++ b/vehicle/src/Vehicle.hs @@ -1,25 +1,23 @@ {-# LANGUAGE NamedFieldPuns #-} module Vehicle - ( main, - mainWithArgsAndExitCode, + ( mainWithArgsAndExitCode, ) where -import Control.Exception (Exception (..), Handler (..), SomeException (..), bracket, catches, handle, throwIO) +import Control.Exception (Exception (..), Handler (..), SomeException (..), catches, handle, throwIO) +import Control.Monad.IO.Class (MonadIO (liftIO)) +import Data.Text qualified as Text (pack) +import Data.Text.IO qualified as TextIO (hPutStrLn) import GHC.IO.Encoding (setLocaleEncoding) -import GHC.IO.Handle (hDuplicate, hDuplicateTo) import Options.Applicative (ParserInfo, defaultPrefs, execParserPure, handleParseResult) import System.Directory (createDirectoryIfMissing) -import System.Environment (getArgs) -import System.Exit (ExitCode (..), exitFailure, exitSuccess, exitWith) +import System.Exit (ExitCode (..), exitFailure, exitSuccess) import System.FilePath (takeDirectory) import System.IO - ( Handle, - IOMode (AppendMode), - hPutStrLn, - stderr, - stdout, + ( BufferMode (NoBuffering), + IOMode (WriteMode), + hSetBuffering, utf8, withFile, ) @@ -27,6 +25,7 @@ import Vehicle.CommandLine (GlobalOptions (..), ModeOptions (..), Options (..), import Vehicle.Compile (compile) import Vehicle.Export (export) import Vehicle.Prelude +import Vehicle.Prelude.IO as VIO (MonadStdIO (writeStderrLn)) import Vehicle.Prelude.Logging import Vehicle.TypeCheck (typeCheck) import Vehicle.Validate (validate) @@ -35,13 +34,7 @@ import Vehicle.Verify (verify) -------------------------------------------------------------------------------- -- Main command -main :: IO () -main = do - args <- getArgs - exitCode <- mainWithArgsAndExitCode args - exitWith (toExitCode exitCode) - -mainWithArgsAndExitCode :: [String] -> IO Int +mainWithArgsAndExitCode :: (MonadStdIO IO) => [String] -> IO Int mainWithArgsAndExitCode args = do setLocaleEncoding utf8 -- Catch any exits and return the exit code, which is important when using @@ -49,82 +42,50 @@ mainWithArgsAndExitCode args = do handle handleExitCode $ do options <- execParserWithArgs commandLineOptionsParserInfo args runVehicle options - exitSuccess + liftIO exitSuccess rethrowExitCode :: ExitCode -> IO () rethrowExitCode = throwIO -uncaughtException :: SomeException -> IO () +uncaughtException :: (MonadStdIO IO) => SomeException -> IO () uncaughtException (SomeException e) = do - hPutStrLn stderr (displayException e) + writeStderrLn (Text.pack $ displayException e) exitFailure -runVehicle :: Options -> IO () +runVehicle :: (MonadStdIO IO) => Options -> IO () runVehicle Options {..} = do - redirections globalOptions $ \ioSettings -> do + withLogger globalOptions $ \logSettings -> do -- Catch uncaught exceptions flip catches [Handler rethrowExitCode, Handler uncaughtException] $ do -- Handle --version if version globalOptions - then putStrLn preciseVehicleVersion + then writeStdoutLn (Text.pack preciseVehicleVersion) else case modeOptions of Nothing -> fatalError "No mode provided. Please use one of 'typeCheck', 'compile', 'verify', 'check', 'export'" Just mode -> case mode of - Check options -> typeCheck ioSettings options - Compile options -> compile ioSettings options - Verify options -> verify ioSettings options - Validate options -> validate ioSettings options - Export options -> export ioSettings options - -redirections :: GlobalOptions -> (LoggingSettings -> IO a) -> IO a -redirections go = redirectStdout go . redirectStderr go . withLogger go - -redirectStdout :: GlobalOptions -> IO a -> IO a -redirectStdout GlobalOptions {outFile} action = - flip (maybe action) outFile $ \fp -> do - createDirectoryIfMissing True (takeDirectory fp) - result <- withFile fp AppendMode $ \fh -> do - bracket (redirectHandleTo stdout fh) (restoreHandleFrom stdout) (const action) - return result - -redirectStderr :: GlobalOptions -> IO a -> IO a -redirectStderr GlobalOptions {errFile} action = - flip (maybe action) errFile $ \fp -> do - createDirectoryIfMissing True (takeDirectory fp) - withFile fp AppendMode $ \fh -> do - bracket (redirectHandleTo stderr fh) (restoreHandleFrom stderr) (const action) + Check options -> typeCheck logSettings options + Compile options -> compile logSettings options + Verify options -> verify logSettings options + Validate options -> validate logSettings options + Export options -> export logSettings options -withLogger :: GlobalOptions -> (LoggingSettings -> IO a) -> IO a +withLogger :: (MonadStdIO IO) => GlobalOptions -> (LoggingSettings -> IO a) -> IO a withLogger GlobalOptions {logFile, loggingLevel} action = case logFile of - Nothing -> action LoggingSettings {logHandle = stderr, loggingLevel} + Nothing -> action LoggingSettings {putLogLn = VIO.writeStderrLn, loggingLevel} Just fp -> do createDirectoryIfMissing True (takeDirectory fp) - withFile fp AppendMode $ \logHandle -> do - action LoggingSettings {logHandle, loggingLevel} - -redirectHandleTo :: Handle -> Handle -> IO Handle -redirectHandleTo source target = do - backup <- hDuplicate source - hDuplicateTo target source - return backup - -restoreHandleFrom :: Handle -> Handle -> IO () -restoreHandleFrom source backup = do - hDuplicateTo backup source - -toExitCode :: Int -> ExitCode -toExitCode exitCode - | exitCode == 0 = ExitSuccess - | otherwise = ExitFailure exitCode + withFile fp WriteMode $ \logHandle -> do + hSetBuffering logHandle NoBuffering + action LoggingSettings {putLogLn = TextIO.hPutStrLn logHandle, loggingLevel} execParserWithArgs :: ParserInfo a -> [String] -> IO a execParserWithArgs parserInfo args = handleParseResult (execParserPure defaultPrefs parserInfo args) -handleExitCode :: ExitCode -> IO Int +handleExitCode :: (MonadIO m) => ExitCode -> m Int handleExitCode = return . fromExitCode where fromExitCode :: ExitCode -> Int diff --git a/vehicle/src/Vehicle/Backend/Agda/CapitaliseTypeNames.hs b/vehicle/src/Vehicle/Backend/Agda/CapitaliseTypeNames.hs index 997178380..b7bbb5c42 100644 --- a/vehicle/src/Vehicle/Backend/Agda/CapitaliseTypeNames.hs +++ b/vehicle/src/Vehicle/Backend/Agda/CapitaliseTypeNames.hs @@ -8,6 +8,7 @@ import Control.Monad.State (MonadState (..), evalState, modify) import Data.Set (Set, insert, member) import Vehicle.Compile.Prelude import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr -------------------------------------------------------------------------------- -- Capitalise type names diff --git a/vehicle/src/Vehicle/Backend/Agda/Compile.hs b/vehicle/src/Vehicle/Backend/Agda/Compile.hs index d5ca00a08..e56b2fdb4 100644 --- a/vehicle/src/Vehicle/Backend/Agda/Compile.hs +++ b/vehicle/src/Vehicle/Backend/Agda/Compile.hs @@ -28,7 +28,7 @@ import Vehicle.Compile.Normalise.NBE (findInstanceArg) import Vehicle.Compile.Prelude import Vehicle.Compile.Print import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Libraries.StandardLibrary.Definitions import Vehicle.Syntax.Sugar diff --git a/vehicle/src/Vehicle/Backend/Agda/Interact.hs b/vehicle/src/Vehicle/Backend/Agda/Interact.hs index 3be236a48..8d2aff0f6 100644 --- a/vehicle/src/Vehicle/Backend/Agda/Interact.hs +++ b/vehicle/src/Vehicle/Backend/Agda/Interact.hs @@ -11,10 +11,11 @@ import System.Directory (createDirectoryIfMissing) import System.FilePath (takeDirectory) import Vehicle.Backend.Prelude import Vehicle.Prelude +import Vehicle.Prelude.IO as VIO (MonadStdIO (writeStdoutLn)) import Vehicle.Prelude.Logging writeAgdaFile :: - (MonadLogger m, MonadIO m) => + (MonadLogger m, MonadIO m, MonadStdIO m) => Maybe FilePath -> Doc a -> m () @@ -31,7 +32,7 @@ agdaOutputFormat = -- TODO This really needs to move. writeResultToFile :: - (MonadIO m, MonadLogger m) => + (MonadIO m, MonadStdIO m, MonadLogger m) => Maybe ExternalOutputFormat -> Maybe FilePath -> Doc a -> @@ -39,7 +40,7 @@ writeResultToFile :: writeResultToFile target filepath doc = do let text = layoutAsText $ prependfileHeader doc target case filepath of - Nothing -> liftIO $ TIO.putStrLn text + Nothing -> VIO.writeStdoutLn text Just outputFilePath -> do logDebug MaxDetail $ "Creating file:" <+> pretty filepath liftIO $ do diff --git a/vehicle/src/Vehicle/Backend/JSON.hs b/vehicle/src/Vehicle/Backend/JSON.hs index c8bd38bce..db8efa1fb 100644 --- a/vehicle/src/Vehicle/Backend/JSON.hs +++ b/vehicle/src/Vehicle/Backend/JSON.hs @@ -25,11 +25,12 @@ import Vehicle.Compile.Arity (Arity, arityFromVType, explicitArityFromType) import Vehicle.Compile.Context.Var import Vehicle.Compile.Descope (DescopeNamed (..)) import Vehicle.Compile.Error (MonadCompile, compilerDeveloperError, illTypedError, resolutionError) -import Vehicle.Compile.Normalise.NBE (normalise, normaliseInEmptyEnv) +import Vehicle.Compile.Normalise.NBE (normalise) import Vehicle.Compile.Prelude (DefAbstractSort (..), Doc, HasType (..), LoggingLevel (..), getExplicitArg, indent, layoutAsText, line, logCompilerPass, logDebug, pretty, prettyJSONConfig, quotePretty, squotes, (<+>)) import Vehicle.Compile.Print (prettyVerbose) import Vehicle.Data.BuiltinInterface (HasStandardData, PrintableBuiltin, TypableBuiltin (..)) import Vehicle.Data.BuiltinInterface qualified as V +import Vehicle.Data.BuiltinInterface.Expr (pattern AnnExpr, pattern UnitLiteral) import Vehicle.Data.DeBruijn import Vehicle.Data.RelevantExpr import Vehicle.Syntax.AST (Name, Position (..), Provenance (..), UniverseLevel) @@ -457,6 +458,8 @@ toJExpr expr = case expr of V.Hole {} -> resolutionError currentPass "Hole" V.Meta {} -> resolutionError currentPass "Meta" V.Universe p (V.UniverseLevel l) -> return $ Universe p l + -- Strip out type-annotations + AnnExpr _ _t e -> toJExpr e V.Builtin p b -> do boundCtx <- getBoundCtx (Proxy @builtin) let boundCtxNames = fmap (fromMaybe "" . V.nameOf) boundCtx @@ -464,8 +467,6 @@ toJExpr expr = case expr of return $ Builtin p jBuiltin V.BoundVar p v -> return $ BoundVar p v V.FreeVar p v -> return $ FreeVar p $ V.nameOf v - -- Strip out type-annotations - V.AnnExpr _ _t e -> toJExpr e -- Otherwise, calculate whether function is partial or not. V.App p fun args -> do fun' <- toJExpr fun @@ -508,7 +509,7 @@ foldLamBinders = \case -- TODO this check is a massive hack. Should go once we get irrelevance up -- and running. | V.isExplicit binder -> first (binder :) (foldLamBinders body) - | otherwise -> foldLamBinders (V.UnitLiteral mempty `substDBInto` body) + | otherwise -> foldLamBinders (UnitLiteral mempty `substDBInto` body) expr -> ([], expr) toJBinder :: (MonadJSON builtin m) => V.Binder Ix builtin -> m (JBinder Ix) @@ -549,7 +550,7 @@ functionArity = go V.Hole {} -> illTypedError currentPass (prettyVerbose fun) V.FreeVar _p ident -> do decl <- getDecl (Proxy @builtin) currentPass ident - normType <- normaliseInEmptyEnv $ typeOf decl + let normType = typeOf decl logDebug MaxDetail $ prettyVerbose normType return $ arityFromVType normType V.BoundVar _ ix -> do diff --git a/vehicle/src/Vehicle/Backend/LossFunction/Compile.hs b/vehicle/src/Vehicle/Backend/LossFunction/Compile.hs index 667066306..764199d92 100644 --- a/vehicle/src/Vehicle/Backend/LossFunction/Compile.hs +++ b/vehicle/src/Vehicle/Backend/LossFunction/Compile.hs @@ -13,8 +13,7 @@ import Vehicle.Compile.Error import Vehicle.Compile.Prelude import Vehicle.Compile.Type.Subsystem (resolveInstanceArguments, typeCheckWithSubsystem) import Vehicle.Compile.Type.Subsystem.Standard.Core qualified as S -import Vehicle.Data.BuiltinInterface -import Vehicle.Data.BuiltinPatterns +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Libraries.StandardLibrary.Definitions import Vehicle.Syntax.Builtin (Builtin) @@ -31,9 +30,16 @@ compile logic typedProg = logCompilerPass MinDetail currentPass $ do let logicImplementation = implementationOf logic + -- MASSIVE HACK. The standard library function `StdNotBoolOp2` is used by + -- the verifier backend but not anything else. However it contains a `Not` + -- that cannot be pushed in and therefore causes DL2 to error. To avoid + -- this we simply remove it from the program here. The better approach + -- would be only to compile things as we need them in loss functions. + let filteredProg = filterDecls (\d -> identifierOf d /= identifierOf StdNotBoolOp2) typedProg + -- Some logics require some preprocessing (e.g. DL2 requires that negation -- is pushed all the way in.) - reformattedProg <- preprocessLogicalOperators logicImplementation typedProg + reformattedProg <- preprocessLogicalOperators logicImplementation filteredProg let instanceCandidates = lossBuiltinInstances logicImplementation lossProgWithInstances <- typeCheckWithSubsystem instanceCandidates throwError reformattedProg diff --git a/vehicle/src/Vehicle/Backend/LossFunction/Logics.hs b/vehicle/src/Vehicle/Backend/LossFunction/Logics.hs index ef4cfa87e..26b7f17ee 100644 --- a/vehicle/src/Vehicle/Backend/LossFunction/Logics.hs +++ b/vehicle/src/Vehicle/Backend/LossFunction/Logics.hs @@ -8,7 +8,7 @@ where import Vehicle.Backend.LossFunction.TypeSystem.Core import Vehicle.Backend.Prelude (DifferentiableLogicID (..)) import Vehicle.Compile.Prelude (developerError) -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.DSL import Vehicle.Data.DSL import Vehicle.Syntax.Builtin diff --git a/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem.hs b/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem.hs index e3c889e6f..cf07a6327 100644 --- a/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem.hs +++ b/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem.hs @@ -21,6 +21,8 @@ import Vehicle.Compile.Type.Core import Vehicle.Compile.Type.Monad import Vehicle.Compile.Type.Subsystem.Standard.Core qualified as S import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr import Vehicle.Syntax.Builtin (BuiltinType (..)) diff --git a/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem/InstanceBuiltins.hs b/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem/InstanceBuiltins.hs index 8a98e78c6..bdc216b91 100644 --- a/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem/InstanceBuiltins.hs +++ b/vehicle/src/Vehicle/Backend/LossFunction/TypeSystem/InstanceBuiltins.hs @@ -10,7 +10,7 @@ import Vehicle.Backend.LossFunction.TypeSystem.Core import Vehicle.Compile.Type.Constraint.Core import Vehicle.Compile.Type.Core import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.DSL import Vehicle.Data.DSL lossBuiltinInstances :: @@ -129,13 +129,11 @@ mkCandidates DifferentialLogicImplementation {..} = quantifierCandidates = [ ( forAllTypes $ \t -> hasQuant Forall (t ~> tLoss) tLoss, - explLam "t" type0 $ \_t -> - compileForall + explLam "t" type0 $ const compileForall ), ( forAllTypes $ \t -> hasQuant Exists (t ~> tLoss) tLoss, - explLam "t" type0 $ \_t -> - compileExists + explLam "t" type0 $ const compileExists ) ] diff --git a/vehicle/src/Vehicle/Backend/Queries.hs b/vehicle/src/Vehicle/Backend/Queries.hs index 53e2c4ea8..af5c67a93 100644 --- a/vehicle/src/Vehicle/Backend/Queries.hs +++ b/vehicle/src/Vehicle/Backend/Queries.hs @@ -3,39 +3,29 @@ module Vehicle.Backend.Queries ) where -import Control.Monad (unless, when) +import Control.Monad (when) import Control.Monad.Except (MonadError (..)) import Control.Monad.IO.Class (MonadIO (..)) import Control.Monad.Reader (MonadReader (..), ReaderT (..)) -import Control.Monad.State (MonadState (..), evalStateT) -import Data.List.NonEmpty as NonEmpty (unzip) -import Data.Map (Map) -import Data.Map qualified as Map -import Data.Maybe (fromMaybe, mapMaybe, maybeToList) -import Data.Traversable (for) +import Data.Bifunctor (Bifunctor (..)) +import Data.Maybe (isNothing, maybeToList) +import Data.Proxy (Proxy (..)) import System.Directory (createDirectoryIfMissing) import Vehicle.Backend.Queries.Error -import Vehicle.Backend.Queries.IfElimination (unfoldIf) -import Vehicle.Backend.Queries.LinearExpr -import Vehicle.Backend.Queries.NetworkElimination -import Vehicle.Backend.Queries.QuerySetStructure -import Vehicle.Backend.Queries.UsedFunctions +import Vehicle.Backend.Queries.PostProcessing (compileQueryToFormat) import Vehicle.Backend.Queries.UserVariableElimination (eliminateUserVariables) -import Vehicle.Backend.Queries.Variable (MixedVariables (MixedVariables), NetworkVariable (..), UserVariableCtx, pattern VInfiniteQuantifier) +import Vehicle.Backend.Queries.UserVariableElimination.Core import Vehicle.Compile.Context.Free import Vehicle.Compile.Error import Vehicle.Compile.ExpandResources (expandResources) import Vehicle.Compile.ExpandResources.Core import Vehicle.Compile.Normalise.NBE import Vehicle.Compile.Prelude -import Vehicle.Compile.Print (prettyFriendlyEmptyCtx, prettyVerbose) import Vehicle.Compile.Print.Warning () import Vehicle.Compile.Type.Subsystem.Standard import Vehicle.Data.BooleanExpr -import Vehicle.Data.BuiltinInterface -import Vehicle.Data.BuiltinPatterns +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr -import Vehicle.Libraries.StandardLibrary.Definitions (StdLibFunction (StdEqualsVector)) import Vehicle.Prelude.Warning (CompileWarning (..)) import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat @@ -52,7 +42,7 @@ currentPass = "compilation of properties" -- verifier and outputs them. We need to output them as they are generated as -- otherwise storing all the queries can result in an out-of-memory errors. compileToQueries :: - (MonadIO m, MonadCompile m) => + (MonadStdIO m, MonadCompile m) => QueryFormat -> Prog Ix Builtin -> Resources -> @@ -66,13 +56,13 @@ compileToQueries queryFormat typedProg resources maybeVerificationFolder = Just folder -> liftIO $ createDirectoryIfMissing True folder -- Expand out the external resources in the specification (datasets, networks etc.) - (Main resourceFreeDecls, networkCtx, freeCtx, integrityInfo) <- expandResources resources typedProg + (Main resourceFreeDecls, networkCtx, freeCtx, integrityInfo) <- + expandResources resources typedProg -- Perform the actual compilation to queries properties <- - runFreeContextT - freeCtx - (compileDecls typedProg queryFormat networkCtx mempty resourceFreeDecls maybeVerificationFolder) + runFreeContextT freeCtx $ + compileDecls typedProg queryFormat networkCtx 0 resourceFreeDecls maybeVerificationFolder -- Check that there were actually properties in the specification. when (null properties) $ do @@ -88,74 +78,80 @@ compileToQueries queryFormat typedProg resources maybeVerificationFolder = -- Getting properties compileDecls :: - (MonadIO m, MonadCompile m, MonadFreeContext Builtin m) => + (MonadStdIO m, MonadCompile m, MonadFreeContext Builtin m) => Prog Ix Builtin -> QueryFormat -> NetworkContext -> - UsedFunctionsCtx -> + PropertyID -> [Decl Ix Builtin] -> Maybe FilePath -> m [(Name, MultiProperty ())] compileDecls _ _ _ _ [] _ = return [] -compileDecls prog queryFormat networkCtx usedFunctionCtx (d : ds) outputLocation = do +compileDecls prog queryFormat networkCtx propertyID (d : ds) outputLocation = do property <- case d of DefFunction p ident anns _ body - | isProperty anns -> - Just - <$> compilePropertyDecl prog queryFormat networkCtx usedFunctionCtx p ident body outputLocation + | isProperty anns -> do + unalteredFreeContext <- getFreeCtx (Proxy @Builtin) + let propertyData = (queryFormat, unalteredFreeContext, networkCtx, (ident, p), propertyID) + locallyAdjustCtx (Proxy @Builtin) convertVectorOpsToPostulates $ do + Just <$> compilePropertyDecl prog propertyData body outputLocation _ -> return Nothing - let maybeUsedFunctionsInfo = getUsedFunctions usedFunctionCtx mempty <$> bodyOf d - let usedFunctionsInfo = fromMaybe mempty maybeUsedFunctionsInfo - -- We use `insertWith` to choose the old value here because expanded resources already exist in the map. - let newUsedFunctionCtx = Map.insertWith (const id) (identifierOf d) usedFunctionsInfo usedFunctionCtx - addDeclToContext d $ do - properties <- compileDecls prog queryFormat networkCtx newUsedFunctionCtx ds outputLocation + let newPropertyID = if isNothing property then propertyID else propertyID + 1 + properties <- compileDecls prog queryFormat networkCtx newPropertyID ds outputLocation return $ maybeToList property ++ properties +type MultiPropertyMetaData = + ( QueryFormat, + FreeCtx Builtin, + NetworkContext, + DeclProvenance, + Int + ) + +updateMetaData :: MultiPropertyMetaData -> TensorIndices -> PropertyMetaData +updateMetaData (queryFormat, unalteredFreeCtx, networkCtx, declProvenance, propertyID) indices = + PropertyMetaData + { networkCtx = networkCtx, + queryFormat = queryFormat, + unalteredFreeContext = unalteredFreeCtx, + propertyProvenance = declProvenance, + propertyAddress = PropertyAddress propertyID (nameOf $ fst declProvenance) indices + } + compilePropertyDecl :: - (MonadIO m, MonadCompile m, MonadFreeContext Builtin m) => + (MonadStdIO m, MonadCompile m, MonadFreeContext Builtin m) => Prog Ix Builtin -> - QueryFormat -> - NetworkContext -> - UsedFunctionsCtx -> - Provenance -> - Identifier -> + MultiPropertyMetaData -> Expr Ix Builtin -> Maybe FilePath -> m (Name, MultiProperty ()) -compilePropertyDecl prog queryFormat networkCtx queryFreeCtx p ident expr outputLocation = do +compilePropertyDecl prog propertyData@(_, _, _, declProv@(ident, _), _) expr outputLocation = do logCompilerPass MinDetail ("property" <+> quotePretty ident) $ do - normalisedExpr <- whilePreservingOperations vectorOperations $ normaliseInEmptyEnv expr - - let computeProperty = compileMultiProperty queryFormat networkCtx queryFreeCtx p ident outputLocation normalisedExpr - - property <- - computeProperty `catchError` \e -> do - let formatID = queryFormatID queryFormat - case e of - UnsupportedNonLinearConstraint {} -> throwError =<< diagnoseNonLinearity formatID prog (ident, p) - UnsupportedAlternatingQuantifiers {} -> throwError =<< diagnoseAlternatingQuantifiers formatID prog (ident, p) - _ -> throwError e - - return (nameOf ident, property) + normalisedExpr <- normaliseInEmptyEnv expr + multiProperty <- + compileMultiProperty propertyData outputLocation normalisedExpr + `catchError` handlePropertyCompileError prog propertyData + return (nameOf (fst declProv), multiProperty) + +handlePropertyCompileError :: (MonadCompile m) => Prog Ix Builtin -> MultiPropertyMetaData -> CompileError -> m a +handlePropertyCompileError prog (queryFormat, _, _, declProv, _) e = case e of + UnsupportedNonLinearConstraint {} -> throwError =<< diagnoseNonLinearity (queryFormatID queryFormat) prog declProv + UnsupportedAlternatingQuantifiers {} -> throwError =<< diagnoseAlternatingQuantifiers (queryFormatID queryFormat) prog declProv + _ -> throwError e -- | Compiles a property of type `Tensor Bool dims` for some variable `dims`, -- by recursing through the levels of vectors until it reaches something of -- type `Bool`. compileMultiProperty :: forall m. - (MonadIO m, MonadCompile m, MonadFreeContext Builtin m) => - QueryFormat -> - NetworkContext -> - UsedFunctionsCtx -> - Provenance -> - Identifier -> + (MonadStdIO m, MonadFreeContext QueryBuiltin m) => + MultiPropertyMetaData -> Maybe FilePath -> WHNFValue Builtin -> m (MultiProperty ()) -compileMultiProperty queryFormat networkCtx freeCtx p ident outputLocation = go [] +compileMultiProperty multiPropertyMetaData outputLocation = go [] where go :: TensorIndices -> WHNFValue Builtin -> m (MultiProperty ()) go indices expr = case expr of @@ -163,205 +159,40 @@ compileMultiProperty queryFormat networkCtx freeCtx p ident outputLocation = go let es' = zip [0 :: QueryID ..] es MultiProperty <$> traverse (\(i, e) -> go (i : indices) (argExpr e)) es' _ -> do + let propertyMetaData@PropertyMetaData {..} = updateMetaData multiPropertyMetaData indices let logFunction = if null indices then id - else logCompilerPass MinDetail ("property" <+> squotes (pretty ident <> pretty (showTensorIndices indices))) - - logFunction $ do - let propertyAddress = PropertyAddress (nameOf ident) indices - let propertyState = PropertyState queryFormat freeCtx networkCtx (ident, p) propertyAddress - evalStateT (runReaderT (compileProperty outputLocation expr) propertyState) 1 - return $ SingleProperty propertyAddress () - --------------------------------------------------------------------------------- --- Compilation - -data PropertyState = PropertyState - { queryFormat :: QueryFormat, - usedFunctionsCtx :: UsedFunctionsCtx, - networkCtx :: NetworkContext, - declProvenance :: DeclProvenance, - propertyAddress :: PropertyAddress - } - -type MonadCompileProperty m = - ( MonadCompile m, - MonadReader PropertyState m, - MonadState QueryID m, - MonadFreeContext Builtin m - ) + else logCompilerPass MinDetail ("property" <+> quotePretty propertyAddress) + flip runReaderT propertyMetaData $ do + logFunction $ do + compileSingleProperty outputLocation expr + return $ SingleProperty propertyAddress () -- Compiles an individual property -compileProperty :: - (MonadCompileProperty m, MonadIO m) => +compileSingleProperty :: + (MonadPropertyStructure m, MonadStdIO m) => Maybe FilePath -> WHNFValue Builtin -> m () -compileProperty outputLocation expr = do - property <- compilePropertyTopLevelStructure expr +compileSingleProperty outputLocation expr = do + queries <- eliminateUserVariables expr - PropertyState {..} <- ask - (propertyMetaData, propertyQueries) <- case property of - NonTrivial b -> do - let (metaData, queries) = (NonEmpty.unzip . fmap NonEmpty.unzip) b - return (NonTrivial metaData, NonTrivial queries) - Trivial status -> do - logWarning (TrivialProperty propertyAddress status) - return (Trivial status, Trivial status) + PropertyMetaData {..} <- ask + -- Warn if trivial. + case queries of + Trivial status -> logWarning (TrivialProperty propertyAddress status) + _ -> return () + formattedQueries <- runSupplyT (traverseProperty compileQueryToFormat queries) [1 :: QueryID ..] case outputLocation of Nothing -> do - forQueryInProperty propertyQueries $ \(queryAddress, queryText) -> - programOutput $ line <> line <> pretty queryAddress <> line <> pretty queryText + forQueryInProperty formattedQueries $ \(queryMetaData, queryText) -> + programOutput $ line <> line <> pretty (queryAddress queryMetaData) <> line <> pretty queryText Just folder -> do - writePropertyVerificationPlan folder propertyAddress (PropertyVerificationPlan propertyMetaData) - forQueryInProperty propertyQueries $ writeVerificationQuery queryFormat folder + let queryMetaTree = fmap (fmap (fmap fst)) formattedQueries + writePropertyVerificationPlan folder propertyAddress (PropertyVerificationPlan queryMetaTree) + forQueryInProperty formattedQueries $ writeVerificationQuery queryFormat folder --- | Compiles the top-level structure of a property until it hits the first quantifier. --- Assumptions - expression is well-typed in the empty context and of type Bool. -compilePropertyTopLevelStructure :: - forall m. - (MonadCompileProperty m) => - WHNFValue Builtin -> - m (Property (QueryMetaData, QueryText)) -compilePropertyTopLevelStructure = go - where - go :: WHNFValue Builtin -> m (Property (QueryMetaData, QueryText)) - go expr = case expr of - VBoolLiteral {} -> compileQuerySet False expr - VBuiltinFunction Equals {} _ -> compileQuerySet False expr - VBuiltinFunction Order {} _ -> compileQuerySet False expr - VFreeVar ident _ - | ident == identifierOf StdEqualsVector -> compileQuerySet False expr - VBuiltinFunction And [e1, e2] -> - andTrivial Conjunct <$> go (argExpr e1) <*> go (argExpr e2) - VBuiltinFunction Or [e1, e2] -> - orTrivial Disjunct <$> go (argExpr e1) <*> go (argExpr e2) - VBuiltinFunction Not [e] -> - case eliminateNot (argExpr e) of - Nothing -> compilerDeveloperError $ "Unable to push not through:" <+> prettyVerbose e - Just r -> go r - VBuiltinFunction If [_, c, x, y] -> do - let unfoldedIf = unfoldIf c (argExpr x) (argExpr y) - logDebug MaxDetail $ "Unfolded `if` to" <+> prettyFriendlyEmptyCtx unfoldedIf - go unfoldedIf - VInfiniteQuantifier Exists _ _ _ _ -> compileQuerySet False expr - VInfiniteQuantifier Forall args binder env body -> do - -- Have to check whether to negate the quantifier here, rather than at the top - -- of the property, as we may have parallel quantifiers of different polarities - -- e.g. (forall x . P x) and (exists y . Q y). - logDebug MinDetail ("Negating property..." <> line) - let negBody = BuiltinFunctionExpr mempty Not [Arg mempty Explicit Relevant body] - let negExpr = VInfiniteQuantifier Exists args binder env negBody - compileQuerySet True negExpr - -- This case only happens because we can't yet evaluate neural networks - -- when applied to real inputs. For example - -- `fold (\x r -> x > 0 and r) True (f [0])` won't evaluate because we - -- don't evaluate `f [0]`. If we fix that problem this case should disappear - -- because we can't have any abstract variables in the empty context so we - -- can't block the evaluation of `fold`. - VBuiltinFunction (Fold FoldVector) _ -> compileQuerySet False expr - _ -> unexpectedExprError "compilation of top-level property structure" (prettyVerbose expr) - -compileQuerySet :: - (MonadCompileProperty m) => - Bool -> - WHNFValue Builtin -> - m (MaybeTrivial (BooleanExpr (QuerySet (QueryMetaData, QueryText)))) -compileQuerySet isPropertyNegated expr = do - let subsectionDoc = "compilation of set of queries:" <+> prettyFriendlyEmptyCtx expr - logCompilerPass MaxDetail subsectionDoc $ do - PropertyState {..} <- ask - let target = queryFormatID queryFormat - -- First we attempt to recursively compile down the remaining boolean structure, - -- stopping at the level of individual propositions (e.g. equality or ordering assertions) - (quantifiedVariables, boolExpr, userVariableReductionInfo) <- - compileSetQueryStructure target declProvenance usedFunctionsCtx networkCtx expr - - metaNetworkPartitions <- replaceNetworkApplications declProvenance networkCtx quantifiedVariables boolExpr - let numberedMetaNetworkPartitions = zipDisjuncts [1 ..] metaNetworkPartitions - let compilePartition = compileMetaNetworkPartition userVariableReductionInfo quantifiedVariables - queries <- traverse compilePartition numberedMetaNetworkPartitions - let maybeFlattenedQueries = fmap concatDisjuncts (eliminateTrivialDisjunctions queries) - case maybeFlattenedQueries of - Trivial b -> return $ Trivial (isPropertyNegated `xor` b) - NonTrivial flattenedQueries -> return $ NonTrivial $ Query $ QuerySet isPropertyNegated flattenedQueries - -compileMetaNetworkPartition :: - (MonadCompileProperty m) => - VariableNormalisationSteps -> - UserVariableCtx -> - (Int, MetaNetworkPartition) -> - m (MaybeTrivial (DisjunctAll (QueryAddress, (QueryMetaData, QueryText)))) -compileMetaNetworkPartition userVariableReductionSteps userVariables (partitionID, MetaNetworkPartition {..}) = do - PropertyState {..} <- ask - logCompilerPass MinDetail ("compilation of meta-network partition" <+> pretty partitionID) $ do - -- Convert it into linear satisfaction problems in the network variables - let mixedVariables = MixedVariables userVariables networkVars - clstQueries <- eliminateUserVariables declProvenance metaNetwork mixedVariables partitionExpr - - -- Compile the query to the specific verifiers. - case clstQueries of - Trivial b -> do - logDebug MinDetail $ "Meta-network partition found to be trivially" <+> pretty b - return $ Trivial b - NonTrivial queries -> - NonTrivial - <$> for - queries - ( \(conjunctions, userVariableEliminationSteps) -> do - queryID <- get - put (queryID + 1) - - checkIfInputsWellSpecificied conjunctions - let sortedConjunctions = sortCLSTProblem conjunctions - queryText <- compileQuery queryFormat declProvenance sortedConjunctions - let allVariableSteps = userVariableReductionSteps <> networkNormSteps <> userVariableEliminationSteps - let queryAddress = (propertyAddress, queryID) - let queryData = QueryData metaNetwork allVariableSteps - - logDebug MaxDetail $ "Final query:" <> line <> indent 2 (pretty queryText) <> line - logDebug MaxDetail $ "Variable sequence:" <> line <> indent 2 (pretty allVariableSteps) - - return (queryAddress, (queryData, queryText)) - ) - --- | Checks for presence of under-constrained input variables. -checkIfInputsWellSpecificied :: - (MonadCompileProperty m) => - CLSTProblem -> - m () -checkIfInputsWellSpecificied (CLSTProblem variables assertions) = do - PropertyState {..} <- ask - let property = propertyName propertyAddress - let format = queryFormatID queryFormat - let inputVariables = filter (\v -> inputOrOutput v == Input) variables - let initialStatuses = Map.fromList (fmap (,UnderConstrained Unconstrained) inputVariables) - let finalStatuses = foldr updateStatuses initialStatuses assertions - - -- If Marabou, then warn if all inputs are constant. - -- See https://github.com/NeuralNetworkVerification/Marabou/issues/670 - when (format == MarabouQueries && all (== Constant) finalStatuses) $ - logWarning $ - AllConstantInputsMarabouBug property - - -- Check if all inputs are well-specified. - let underSpecified = mapMaybe (\(v, s) -> (v,) <$> toUnderConstrainedStatus s) $ Map.toList finalStatuses - unless (null underSpecified) $ - logWarning $ - UnderSpecifiedNetworkInputs property format underSpecified - where - updateStatuses :: - Assertion NetworkVariable -> - Map NetworkVariable VariableConstraintStatus -> - Map NetworkVariable VariableConstraintStatus - updateStatuses assertion statuses = case coefficientsList assertion of - [(v, c)] | inputOrOutput v == Input -> do - let status = case assertionRel assertion of - Equal -> Constant - _ - | c >= 0 -> UnderConstrained BoundedAbove - | otherwise -> UnderConstrained BoundedBelow - Map.insertWith (<>) v status statuses - _ -> statuses +convertVectorOpsToPostulates :: FreeCtx Builtin -> FreeCtx Builtin +convertVectorOpsToPostulates = alterKeys vectorOperations (first convertToPostulate) diff --git a/vehicle/src/Vehicle/Backend/Queries/ConstraintSearch.hs b/vehicle/src/Vehicle/Backend/Queries/ConstraintSearch.hs new file mode 100644 index 000000000..6303d7b5b --- /dev/null +++ b/vehicle/src/Vehicle/Backend/Queries/ConstraintSearch.hs @@ -0,0 +1,105 @@ +module Vehicle.Backend.Queries.ConstraintSearch + ( findVariableConstraints, + ConstrainedAssertionTree (..), + ConstraintSearchCriteria, + ) +where + +import Control.Monad (foldM) +import Data.Either (partitionEithers) +import Data.List.NonEmpty (NonEmpty (..)) +import Data.List.NonEmpty qualified as NonEmpty +import Data.Void (Void, absurd) +import Vehicle.Backend.Queries.UserVariableElimination.Core +import Vehicle.Compile.Error +import Vehicle.Compile.Prelude +import Vehicle.Data.BooleanExpr + +-------------------------------------------------------------------------------- +-- Data + +-- | The strongest set of available constraints for a given variable. Equalities +-- are stronger than inequalities. Is parameterised by the type of equality +-- field so we can either look for rational equalities, tensor equalities or +-- no equalties at all. +data ConstrainedAssertionTree equality + = Equality (equality, MaybeTrivial AssertionTree) + | Inequalities (ConjunctAll RationalInequality, MaybeTrivial AssertionTree) + | NoConstraints AssertionTree + +instance (Pretty equality) => Pretty (ConstrainedAssertionTree equality) where + pretty = \case + Equality e -> "Equalities[" <+> pretty e <+> "]" + Inequalities es -> "Inequalities[" <+> pretty es <+> "]" + NoConstraints e -> "NoConstraints[" <+> pretty e <+> "]" + +-- | A scheme for pulling out constraints from assertions. Used to control +-- which assertions are considered valid constraints. +type ConstraintSearchCriteria variable equality = + variable -> Assertion -> ConstrainedAssertionTree equality + +-------------------------------------------------------------------------------- +-- Algorithm + +-- Takes in a tree of assertions and partitions it only as much as strictly +-- necessary to find the strongest set of constraints over the variable. +findVariableConstraints :: + forall m variable equality. + (Pretty equality, MonadCompile m) => + ConstraintSearchCriteria variable equality -> + variable -> + AssertionTree -> + m (DisjunctAll (ConstrainedAssertionTree equality)) +findVariableConstraints fromAssertion var = go + where + go :: AssertionTree -> m (DisjunctAll (ConstrainedAssertionTree equality)) + go = \case + Query assertion -> return $ DisjunctAll [fromAssertion var assertion] + Disjunct xs -> disjunctDisjuncts <$> traverse go xs + Conjunct (ConjunctAll (NonEmpty.reverse -> x :| xs)) -> do + r1 <- go x + rs' <- foldM andDisjuncts (x, r1) xs + return $ snd rs' + + andDisjuncts :: + (AssertionTree, DisjunctAll (ConstrainedAssertionTree equality)) -> + AssertionTree -> + m (AssertionTree, DisjunctAll (ConstrainedAssertionTree equality)) + andDisjuncts (x, r1) y = do + let (shortCircuitedLHS, remainingLHS) = partitionEithers $ fmap (shortCircuitConstraints y) (disjunctsToList r1) + result <- + if null remainingLHS + then return shortCircuitedLHS + else do + r2 <- go y + let (shortCircuitedRHS, remainingRHS) = partitionEithers $ fmap (shortCircuitConstraints x) (disjunctsToList r2) + if null remainingRHS + then return shortCircuitedRHS + else do + let remainingDisjuncts = cartesianProduct mergeConstraints remainingLHS remainingRHS + return $ shortCircuitedLHS <> shortCircuitedRHS <> remainingDisjuncts + + case result of + r : rs -> return (andBoolExpr x y, DisjunctAll (r :| rs)) + [] -> compilerDeveloperError "The conjunctions of non-empty disjunctions should be non-empty." + + shortCircuitConstraints :: + AssertionTree -> + ConstrainedAssertionTree equality -> + Either (ConstrainedAssertionTree equality) (ConstrainedAssertionTree Void) + shortCircuitConstraints disjunctedTree constraint = case constraint of + Equality (eq, remaining) -> Left $ Equality (eq, andTrivial andBoolExpr remaining (NonTrivial disjunctedTree)) + Inequalities ineq -> Right (Inequalities ineq) + NoConstraints ineq -> Right (NoConstraints ineq) + + mergeConstraints :: + ConstrainedAssertionTree Void -> + ConstrainedAssertionTree Void -> + ConstrainedAssertionTree equality + mergeConstraints c1 c2 = case (c1, c2) of + (Equality (eq, _), _) -> absurd eq + (_, Equality (eq, _)) -> absurd eq + (NoConstraints t1, NoConstraints t2) -> NoConstraints (andBoolExpr t1 t2) + (NoConstraints t1, Inequalities (ineqs2, t2)) -> Inequalities (ineqs2, andTrivial andBoolExpr (NonTrivial t1) t2) + (Inequalities (ineqs1, t1), NoConstraints t2) -> Inequalities (ineqs1, andTrivial andBoolExpr t1 (NonTrivial t2)) + (Inequalities (ineqs1, t1), Inequalities (ineqs2, t2)) -> Inequalities (ineqs1 <> ineqs2, andTrivial andBoolExpr t1 t2) diff --git a/vehicle/src/Vehicle/Backend/Queries/Error.hs b/vehicle/src/Vehicle/Backend/Queries/Error.hs index 5ca069ec6..e77ea7c66 100644 --- a/vehicle/src/Vehicle/Backend/Queries/Error.hs +++ b/vehicle/src/Vehicle/Backend/Queries/Error.hs @@ -9,6 +9,7 @@ import Vehicle.Backend.Queries.Error.Linearity import Vehicle.Backend.Queries.Error.Polarity import Vehicle.Compile.Error import Vehicle.Compile.Prelude +import Vehicle.Compile.Print (prettyVerbose) import Vehicle.Compile.Type.Subsystem (typeCheckWithSubsystem) import Vehicle.Compile.Type.Subsystem.Standard import Vehicle.Verify.QueryFormat.Core (QueryFormatID) @@ -63,7 +64,7 @@ diagnoseAlternatingQuantifiers queryFormat prog propertyProv@(propertyIdentifier case propertyType of PolarityExpr _ (MixedSequential q p pp2) -> do throwError $ UnsupportedAlternatingQuantifiers queryFormat propertyProv (Right (q, p, pp2)) - _ -> compilerDeveloperError $ "Unexpected polarity type for property" <+> quotePretty propertyIdentifier + _ -> compilerDeveloperError $ "Unexpected polarity type for property" <+> quotePretty propertyIdentifier <> ":" <+> prettyVerbose propertyType where handleUnexpectedError :: (MonadCompile m) => CompileError -> m a handleUnexpectedError err = diff --git a/vehicle/src/Vehicle/Backend/Queries/Error/Linearity/LinearitySolver.hs b/vehicle/src/Vehicle/Backend/Queries/Error/Linearity/LinearitySolver.hs index d5e90a2fb..4b60a17f7 100644 --- a/vehicle/src/Vehicle/Backend/Queries/Error/Linearity/LinearitySolver.hs +++ b/vehicle/src/Vehicle/Backend/Queries/Error/Linearity/LinearitySolver.hs @@ -15,7 +15,7 @@ import Vehicle.Compile.Type.Constraint.Core import Vehicle.Compile.Type.Core import Vehicle.Compile.Type.Monad (MonadTypeChecker) import Vehicle.Compile.Type.Monad.Class (addConstraints, solveMeta, substMetas) -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Data.NormalisedExpr import Vehicle.Syntax.Builtin diff --git a/vehicle/src/Vehicle/Backend/Queries/Error/Polarity/PolaritySolver.hs b/vehicle/src/Vehicle/Backend/Queries/Error/Polarity/PolaritySolver.hs index 374518d9e..06d7446b6 100644 --- a/vehicle/src/Vehicle/Backend/Queries/Error/Polarity/PolaritySolver.hs +++ b/vehicle/src/Vehicle/Backend/Queries/Error/Polarity/PolaritySolver.hs @@ -12,7 +12,7 @@ import Vehicle.Compile.Print (prettyFriendly) import Vehicle.Compile.Type.Constraint.Core import Vehicle.Compile.Type.Core import Vehicle.Compile.Type.Monad -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Data.NormalisedExpr import Vehicle.Syntax.Builtin diff --git a/vehicle/src/Vehicle/Backend/Queries/GaussianElimination.hs b/vehicle/src/Vehicle/Backend/Queries/GaussianElimination.hs deleted file mode 100644 index a6f418f80..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/GaussianElimination.hs +++ /dev/null @@ -1,121 +0,0 @@ -module Vehicle.Backend.Queries.GaussianElimination - ( GaussianVariableSolution, - gaussianElimination, - reconstructGaussianVariableValue, - solutionEquality, - ) -where - -import Control.Monad (foldM, unless) -import Data.Bifunctor -import Data.Coerce (coerce) -import Data.IntSet (IntSet) -import Data.IntSet qualified as IntSet -import Data.Maybe (fromMaybe) -import Vehicle.Backend.Queries.LinearExpr -import Vehicle.Backend.Queries.Variable -import Vehicle.Compile.Error -import Vehicle.Compile.Prelude -import Vehicle.Verify.Core - --- | Performs Gaussian elimination. Returns a list of solved variables, the remaining --- unused assertions and the indices of the solved assertions. -gaussianElimination :: - (MonadCompile m) => - MixedVariableCtx -> - [GaussianAssertion] -> - m ([(MixedVariable, GaussianAssertion)], [GaussianAssertion], IntSet) -gaussianElimination variablesToEliminate exprs = - logCompilerPass MidDetail currentPhase $ do - logDebug MaxDetail $ prettyExprs exprs - let numberedExprs = zip [0 ..] exprs - (solvedVars, reducedRows, usedRows) <- foldM reduceRow (mempty, numberedExprs, mempty) (reverse variablesToEliminate) - - let unusedExprs = coerce (fmap snd reducedRows) - - unless (null unusedExprs) $ - logDebug MaxDetail $ - line <> pretty ("Unused:" :: String) <> line <> indent 2 (prettyExprs unusedExprs) - - return (solvedVars, unusedExprs, usedRows) - --------------------------------------------------------------------------------- --- Interface - -type GaussianAssertion = SparseLinearExpr MixedVariable - -type Solution = (MixedVariable, SparseLinearExpr MixedVariable) - -type RowID = Int - --------------------------------------------------------------------------------- --- Algorithm - --- | Tries to reduce the provided row in the matrix. --- If unable to reduce it, then it returns the matrix unchanged. -reduceRow :: - (MonadCompile m) => - ([Solution], [(RowID, GaussianAssertion)], IntSet) -> - MixedVariable -> - m ([Solution], [(RowID, GaussianAssertion)], IntSet) -reduceRow (solvedVars, rows, usedRows) var = do - let result@(newSolvedVars', newRows', _) = fromMaybe (solvedVars, rows, usedRows) $ do - ((pivotRowID, pivotRow), remainingRows) <- findPivot var rows - -- Eliminate the row from the remaining rows - let newRows = fmap (second (eliminateVar var pivotRow)) remainingRows - let newSolvedVars = (var, pivotRow) : solvedVars - let newUsedRows = IntSet.insert pivotRowID usedRows - return (newSolvedVars, newRows, newUsedRows) - - logDebug MaxDetail $ - line - <> "After solving for" - <+> quotePretty var - <> ":" - <> line - <> indent - 2 - ( "Solutions:" - <+> pretty newSolvedVars' - <> line - <> "Equations:" - <+> prettyExprs (fmap snd newRows') - ) - return result - --- | Given a variable, tries to find a row with a suitable pivot element to --- eliminate it. -findPivot :: - MixedVariable -> - [(RowID, GaussianAssertion)] -> - Maybe ((RowID, GaussianAssertion), [(RowID, GaussianAssertion)]) -findPivot _ [] = Nothing -findPivot var ((rowID, row) : rows) = do - let coefficient = lookupCoefficient row var - if coefficient == 0 - then second ((rowID, row) :) <$> findPivot var rows - else do - let normalisedRow = scaleExpr (1 / coefficient) row - Just ((rowID, normalisedRow), rows) - --------------------------------------------------------------------------------- --- Solutions - --- | Tries to reconstruct the value of the variable that is --- consistent with the current assignment of variables. Returns either a --- variable that is missing in the assignment of the reconstructed value. -reconstructGaussianVariableValue :: - VariableAssignment MixedVariable -> - GaussianVariableSolution -> - Either MixedVariable VariableValue -reconstructGaussianVariableValue assignment solution = - evaluateExpr (solutionEquality solution) assignment - --------------------------------------------------------------------------------- --- Utilities - -currentPhase :: Doc () -currentPhase = "Gaussian elimination of user variables" - -prettyExprs :: [GaussianAssertion] -> Doc a -prettyExprs exprs = prettyAssertions (fmap (Assertion Equal) exprs) diff --git a/vehicle/src/Vehicle/Backend/Queries/IfElimination.hs b/vehicle/src/Vehicle/Backend/Queries/IfElimination.hs deleted file mode 100644 index ced9e9243..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/IfElimination.hs +++ /dev/null @@ -1,104 +0,0 @@ -{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} - -{-# HLINT ignore "Avoid lambda using `infix`" #-} -module Vehicle.Backend.Queries.IfElimination - ( eliminateIfs, - unfoldIf, - ) -where - -import Vehicle.Compile.Error -import Vehicle.Compile.Prelude -import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BuiltinInterface -import Vehicle.Data.NormalisedExpr - --------------------------------------------------------------------------------- --- Primary function - --- | Lifts all `if`s in the provided expression `e`, and eliminates any which --- live in which is assumed to --- have been normalised and is of type `Bool`. It does this by recursively --- lifting the `if` expression until it reaches a point where we know that it's --- of type `Bool` in which case we then normalise it to an `or` statement. --- --- - `Nothing` indicates no `if`s present --- - `Just Nothing` indicates `if`s present but couldn't be lifted --- - `Just (Just x)` indicates `if`s present and `x` is the result of the --- lifting and eliminating them -eliminateIfs :: - (MonadCompile m) => - WHNFValue Builtin -> - m (Maybe (Maybe (WHNFValue Builtin))) -eliminateIfs e = do - ifLiftedExpr <- recLiftIf e - case ifLiftedExpr of - Nothing -> return $ Just Nothing - Just liftedExpr@(VBuiltinFunction If _) -> - return $ Just $ Just $ elimIf liftedExpr - Just _ -> return Nothing - -currentPass :: Doc a -currentPass = "if elimination" - --------------------------------------------------------------------------------- --- If operations - -liftIf :: (WHNFValue Builtin -> WHNFValue Builtin) -> WHNFValue Builtin -> WHNFValue Builtin -liftIf f (VBuiltinFunction If [t, cond, e1, e2]) = - VBuiltinFunction - If - [ t, - cond, - Arg mempty Explicit Relevant (liftIf f $ argExpr e1), - Arg mempty Explicit Relevant (liftIf f $ argExpr e2) - ] -liftIf f e = f e - -recLiftIf :: (MonadCompile m) => WHNFValue Builtin -> m (Maybe (WHNFValue Builtin)) -recLiftIf expr = case expr of - VPi {} -> unexpectedTypeInExprError currentPass "Pi" - VUniverse {} -> unexpectedTypeInExprError currentPass "Universe" - -- Can't lift over quantified lambda. - VLam {} -> return Nothing - VMeta {} -> return $ Just expr - VBoundVar {} -> return $ Just expr - VFreeVar v spine -> do - maybeLiftedSpine <- sequence <$> (fmap sequence <$> traverse (traverse recLiftIf) spine) - case maybeLiftedSpine of - Nothing -> return Nothing - Just xs -> return $ Just $ liftSpine (VFreeVar v) xs - VBuiltin b spine -> do - maybeLiftedSpine <- sequence <$> (fmap sequence <$> traverse (traverse recLiftIf) spine) - case maybeLiftedSpine of - Nothing -> return Nothing - Just xs -> return $ Just $ liftSpine (VBuiltin b) xs - -liftArg :: (WHNFArg Builtin -> WHNFValue Builtin) -> WHNFArg Builtin -> WHNFValue Builtin -liftArg f (Arg p v r e) = liftIf (f . Arg p v r) e - --- I feel this should be definable in terms of `liftIfs`, but I can't find it. -liftSpine :: - (WHNFSpine Builtin -> WHNFValue Builtin) -> - WHNFSpine Builtin -> - WHNFValue Builtin -liftSpine f [] = f [] -liftSpine f (x : xs) = - if visibilityOf x == Explicit - then liftArg (\a -> liftSpine (\as -> f (a : as)) xs) x - else liftSpine (\as -> f (x : as)) xs - --- | Recursively removes all top-level `if` statements in the current --- provided expression. -elimIf :: WHNFValue Builtin -> WHNFValue Builtin -elimIf (VBuiltinFunction If [_, cond, e1, e2]) = unfoldIf cond (elimIf (argExpr e1)) (elimIf (argExpr e2)) -elimIf e = e - -unfoldIf :: WHNFArg Builtin -> WHNFValue Builtin -> WHNFValue Builtin -> WHNFValue Builtin -unfoldIf c x y = - VBuiltinFunction - Or - $ Arg mempty Explicit Relevant - <$> [ VBuiltinFunction And [c, Arg mempty Explicit Relevant x], - VBuiltinFunction And [Arg mempty Explicit Relevant (VBuiltinFunction Not [c]), Arg mempty Explicit Relevant y] - ] diff --git a/vehicle/src/Vehicle/Backend/Queries/LinearExpr.hs b/vehicle/src/Vehicle/Backend/Queries/LinearExpr.hs deleted file mode 100644 index d3a7c8017..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/LinearExpr.hs +++ /dev/null @@ -1,394 +0,0 @@ -module Vehicle.Backend.Queries.LinearExpr - ( Relation (..), - Assertion (..), - UnreducedAssertion, - VectorEquality (..), - CLSTProblem (..), - SparseLinearExpr (..), - lookupCoefficient, - evaluateExpr, - addExprs, - scaleExpr, - rearrangeExprToSolveFor, - constructReducedAssertion, - isEquality, - prettyAssertions, - referencesVariables, - substitute, - filterTrivialAssertions, - eliminateVar, - convertToSparseFormat, - mapAssertionVariables, - eqToRelation, - ordToRelation, - coefficientsList, - assertionVariables, - sortCLSTProblem, - ) -where - -import Control.Monad (foldM) -import Data.Aeson (FromJSON, FromJSONKey, ToJSON, ToJSONKey) -import Data.Bifunctor (Bifunctor (..)) -import Data.Hashable (Hashable) -import Data.List (sortBy, sortOn) -import Data.List.NonEmpty (NonEmpty (..)) -import Data.Map (Map) -import Data.Map qualified as Map -import Data.Maybe (fromMaybe) -import Data.Set (Set) -import Data.Set qualified as Set -import Data.Vector qualified as Vector -import GHC.Generics (Generic) -import Vehicle.Backend.Queries.Variable -import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.NormalisedExpr -import Vehicle.Prelude -import Vehicle.Syntax.AST - --------------------------------------------------------------------------------- --- Relation - -data Relation - = Equal - | NotEqual - | LessThan - | LessThanOrEqualTo - deriving (Show, Eq, Ord, Generic) - -instance Hashable Relation - -instance ToJSON Relation - -instance FromJSON Relation - -instance Pretty Relation where - pretty = \case - Equal -> "==" - NotEqual -> "!=" - LessThan -> "<" - LessThanOrEqualTo -> "<=" - -relationToOp :: Relation -> Either EqualityOp OrderOp -relationToOp = \case - Equal -> Left Eq - NotEqual -> Left Neq - LessThan -> Right Lt - LessThanOrEqualTo -> Right Le - -eqToRelation :: - WHNFValue Builtin -> - EqualityOp -> - WHNFValue Builtin -> - (WHNFValue Builtin, Relation, WHNFValue Builtin) -eqToRelation e1 op e2 = case op of - Eq -> (e1, Equal, e2) - Neq -> (e1, LessThan, e2) - -ordToRelation :: - WHNFValue Builtin -> - OrderOp -> - WHNFValue Builtin -> - (WHNFValue Builtin, Relation, WHNFValue Builtin) -ordToRelation e1 op e2 = case op of - Lt -> (e1, LessThan, e2) - Le -> (e1, LessThanOrEqualTo, e2) - Gt -> (e2, LessThan, e1) - Ge -> (e2, LessThanOrEqualTo, e1) - --------------------------------------------------------------------------------- --- Variables - -prettyCoefficientVar :: - (Variable variable) => - Bool -> - (variable, Coefficient) -> - Doc a -prettyCoefficientVar isFirst (variable, coefficient) = do - let sign - | coefficient > 0 = if isFirst then "" else "+ " - | otherwise = if isFirst then "-" else "- " - - let value - | coefficient == 1 = pretty variable - | coefficient == -1 = pretty variable - | coefficient > 0 = pretty coefficient <> pretty variable - | otherwise = pretty (-coefficient) <> pretty variable - - sign <> value - --------------------------------------------------------------------------------- --- Sparse representations of linear expressions - -data SparseLinearExpr variable = Sparse - { dimensions :: TensorDimensions, - coefficients :: Map variable Coefficient, - constantValue :: Constant - } - deriving (Show, Eq, Generic) - -instance (Variable variable, ToJSONKey variable) => ToJSON (SparseLinearExpr variable) - -instance (Variable variable, FromJSONKey variable) => FromJSON (SparseLinearExpr variable) - -instance (Variable variable) => Pretty (SparseLinearExpr variable) where - pretty (Sparse dims coefficients constant) = do - -- Append an empty variable name for the constant at the end - let coeffVars = Map.toList coefficients - case coeffVars of - [] -> prettyConstant True dims constant - (x : xs) -> do - let varDocs = prettyCoefficientVar True x : fmap (prettyCoefficientVar False) xs - let constDoc = prettyConstant False dims constant - hsep varDocs <> constDoc - -addExprs :: - (Variable variable) => - Coefficient -> - SparseLinearExpr variable -> - Coefficient -> - SparseLinearExpr variable -> - SparseLinearExpr variable -addExprs c1 (Sparse dims coeff1 const1) c2 (Sparse _ coeff2 const2) = do - -- We should really be able to do this in one operation, but the API isn't flexible enough. - let coeff1' = if c1 == 1 then coeff1 else Map.map (c1 *) coeff1 - let coeff2' = if c2 == 1 then coeff2 else Map.map (c2 *) coeff2 - let rcoeff = Map.filter (/= 0) (Map.unionWith (+) coeff1' coeff2') - let rconst = addConstants c1 const1 c2 const2 - Sparse dims rcoeff rconst - -scaleExpr :: Coefficient -> SparseLinearExpr variable -> SparseLinearExpr variable -scaleExpr c (Sparse dims coefficients constant) = - Sparse dims (Map.map (c *) coefficients) (scaleConstant c constant) - -lookupCoefficient :: (Ord variable) => SparseLinearExpr variable -> variable -> Coefficient -lookupCoefficient (Sparse _ coefficients _) v = fromMaybe 0 $ Map.lookup v coefficients - -isConstant :: SparseLinearExpr variable -> Maybe Constant -isConstant (Sparse _ coeff constant) - | Map.null coeff = Just constant - | otherwise = Nothing - -evaluateExpr :: - forall variable. - (Variable variable) => - SparseLinearExpr variable -> - VariableAssignment variable -> - Either variable Constant -evaluateExpr expr assignment = do - let Sparse _ coefficients constant = expr - foldM op constant (Map.toList coefficients) - where - op :: Constant -> (variable, Coefficient) -> Either variable Constant - op total (var, coeff) = case Map.lookup var assignment of - Nothing -> Left var - Just value -> Right (addConstants 1 total coeff value) - -eliminateVar :: - (Variable variable) => - variable -> - SparseLinearExpr variable -> - SparseLinearExpr variable -> - SparseLinearExpr variable -eliminateVar var solution row = do - let varCoefficient = lookupCoefficient row var - if varCoefficient == 0 - then row - else do - let scaleFactor = varCoefficient / lookupCoefficient solution var - let resultExpr = addExprs 1 row (-scaleFactor) solution - -- Needed to handle floating point errors.... - resultExpr - { coefficients = Map.delete var $ coefficients resultExpr - } - --- | Takes an assertion `a*x_0 + ... + b*x_i + ... c * x_n` and --- returns the RHS of the equation: `x_i = -a/b*x_0 + ... -c/b*x_n` -rearrangeExprToSolveFor :: - (Variable variable) => - variable -> - SparseLinearExpr variable -> - SparseLinearExpr variable -rearrangeExprToSolveFor var expr = do - let c = lookupCoefficient expr var - let scaledExpr = scaleExpr (-1 / c) expr - scaledExpr - { coefficients = Map.delete var $ coefficients scaledExpr - } - -mapExprVariables :: (Variable variable2) => (variable1 -> variable2) -> SparseLinearExpr variable1 -> SparseLinearExpr variable2 -mapExprVariables f Sparse {..} = - Sparse - { coefficients = Map.mapKeys f coefficients, - .. - } - --------------------------------------------------------------------------------- --- Assertion - -data Assertion variable = Assertion - { -- | How the sum of the terms in the linear expression are related. - assertionRel :: Relation, - assertionExpr :: SparseLinearExpr variable - } - deriving (Show, Eq, Generic) - -instance (Variable variable, ToJSONKey variable) => ToJSON (Assertion variable) - -instance (Variable variable, FromJSONKey variable) => FromJSON (Assertion variable) - -instance (Variable variable) => Pretty (Assertion variable) where - pretty (Assertion rel linearExpr) = - pretty linearExpr <+> pretty rel <+> "0.0" - -coefficientsList :: Assertion variable -> [(variable, Coefficient)] -coefficientsList (Assertion _ (Sparse _ coeffs _)) = Map.toList coeffs - -isEquality :: Assertion variable -> Bool -isEquality a = assertionRel a == Equal - -constructReducedAssertion :: - (Variable variable) => - (SparseLinearExpr variable, Relation, SparseLinearExpr variable) -> - Assertion variable -constructReducedAssertion (lhs, rel, rhs) = - Assertion - { assertionExpr = addExprs 1 lhs (-1) rhs, - assertionRel = rel - } - -prettyAssertions :: (Variable variable) => [Assertion variable] -> Doc a -prettyAssertions assertions = - vsep (fmap pretty assertions) - -substitute :: (Variable variable) => Assertion variable -> variable -> SparseLinearExpr variable -> Assertion variable -substitute (Assertion r2 e2) var e1 = Assertion r2 (eliminateVar var e1 e2) - -assertionVariables :: (Variable variable) => Assertion variable -> Set variable -assertionVariables (Assertion _ e) = Set.fromList $ Map.keys $ coefficients e - -referencesVariables :: (Variable variable) => Assertion variable -> Set variable -> Bool -referencesVariables assertion variables = - not $ Set.null $ variables `Set.intersection` assertionVariables assertion - --- | Checks whether an assertion is trivial or not. Returns `Nothing` if --- non-trivial, and otherwise `Just b` where `b` is the value of the assertion --- if it is trivial. -checkTriviality :: Assertion variable -> Maybe Bool -checkTriviality (Assertion rel linexp) = - case isConstant linexp of - Nothing -> Nothing - Just c -> Just $ case rel of - Equal -> Vector.all (== 0.0) c - NotEqual -> Vector.all (/= 0.0) c - LessThan -> Vector.all (< 0.0) c - LessThanOrEqualTo -> Vector.all (<= 0.0) c - -filterTrivialAssertions :: - [Assertion variable] -> - Maybe [Assertion variable] -filterTrivialAssertions = go - where - go :: [Assertion variable] -> Maybe [Assertion variable] - go [] = Just [] - go (a : as) = case go as of - Nothing -> Nothing - Just as' -> case checkTriviality a of - Nothing -> Just $ a : as' - Just True -> Just as' - Just False -> Nothing - --- | Converts an assertion to a sparse format, with various optimisations --- to improve readability, including: --- 1. sorting the variables alphabetically --- 2. negating everything if all variables have negative coefficients. --- 3. moving the constant to the RHS. -convertToSparseFormat :: - Map NetworkVariable Name -> - Assertion NetworkVariable -> - (NonEmpty (Coefficient, Name), Either EqualityOp OrderOp, Rational) -convertToSparseFormat nameMap (Assertion rel linearExpr) = do - let Sparse _ coeffs vectConstant = linearExpr - let varCoeff = sortVarCoeffs coeffs - let missingErr v = developerError $ "Unknown variable" <+> pretty v <+> "when converting to sparse format" - let coeffName = fmap (\(v, c) -> (c, Map.findWithDefault (missingErr v) v nameMap)) varCoeff - let op = relationToOp rel - let constant = vectConstant Vector.! 0 - - -- Move constant to RHS - let rhsConstant = -constant - - -- Make the properties a tiny bit nicer by checking if all the vars are - -- negative and if so negating everything. - let allCoefficientsNegative = all (\(c, _) -> c < 0) coeffName - let (almostFinalCoeff, finalOp, finalConstant) = - if not allCoefficientsNegative - then (coeffName, op, rhsConstant) - else do - let negCoeffNames = fmap (\(c, v) -> (-c, v)) coeffName - let negOp = second flipOrder op - let negConstant = -rhsConstant - (negCoeffNames, negOp, negConstant) - - let finalCoeff = case almostFinalCoeff of - (c : cs) -> c :| cs - [] -> developerError "Found trivial assertion" - - (finalCoeff, finalOp, finalConstant) - -sortVarCoeffs :: Map NetworkVariable Coefficient -> [(NetworkVariable, Coefficient)] -sortVarCoeffs coeffs = do - let coeffsList = Map.toList coeffs - let getKey (var, _) = (inputOrOutput var, networkVarIndices var) - sortOn getKey coeffsList - -mapAssertionVariables :: (Variable variable2) => (variable1 -> variable2) -> Assertion variable1 -> Assertion variable2 -mapAssertionVariables f Assertion {..} = - Assertion - { assertionExpr = mapExprVariables f assertionExpr, - .. - } - --------------------------------------------------------------------------------- --- Unreduced assertions - --- | A not fully reduced assertion, but none the less only represents --- conjunctions. -type UnreducedAssertion = WHNFValue Builtin - --- | An encoding of a vector equality. -data VectorEquality = VectorEquality - { assertionLHS :: WHNFValue Builtin, - assertionRHS :: WHNFValue Builtin, - assertionDims :: TensorDimensions - } - --------------------------------------------------------------------------------- --- Linear satisfaction problem - --- | Conjunctive linear satisfaction problem, parameterised by the type of --- variables it is over. -data CLSTProblem = CLSTProblem NetworkVariableCtx [Assertion NetworkVariable] - -instance Pretty CLSTProblem where - pretty (CLSTProblem _varNames assertions) = pretty assertions - --- | Sorts the assertions in the CLST problem in order to avoid getting massive --- changes to output files every time our compilation algorithm changes --- (see #591). -sortCLSTProblem :: CLSTProblem -> CLSTProblem -sortCLSTProblem (CLSTProblem vars assertions) = do - let sortedAssertions = sortBy compareAssertion assertions - CLSTProblem vars sortedAssertions - where - compareAssertion :: Assertion NetworkVariable -> Assertion NetworkVariable -> Ordering - compareAssertion (Assertion rel1 expr1) (Assertion rel2 expr2) = - compareExpression expr1 expr2 `thenCmp` compare rel1 rel2 - - compareExpression :: SparseLinearExpr NetworkVariable -> SparseLinearExpr NetworkVariable -> Ordering - compareExpression (Sparse _dims1 coefs1 const1) (Sparse _dims2 coefs2 const2) = - compare coefs1 coefs2 `thenCmp` compare const1 const2 - - thenCmp :: Ordering -> Ordering -> Ordering - thenCmp EQ o2 = o2 - thenCmp o1 _ = o1 diff --git a/vehicle/src/Vehicle/Backend/Queries/NetworkElimination.hs b/vehicle/src/Vehicle/Backend/Queries/NetworkElimination.hs deleted file mode 100644 index bdee74d98..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/NetworkElimination.hs +++ /dev/null @@ -1,448 +0,0 @@ -{-# LANGUAGE DeriveAnyClass #-} - -module Vehicle.Backend.Queries.NetworkElimination - ( MetaNetworkPartition (..), - replaceNetworkApplications, - ) -where - -import Control.Monad (unless) -import Control.Monad.Except (MonadError (..)) -import Control.Monad.Reader (MonadReader (..), ReaderT (..)) -import Control.Monad.State (MonadState (..), evalStateT, gets, modify) -import Data.Bifunctor (Bifunctor (..)) -import Data.Foldable (foldlM) -import Data.Functor.Classes (Ord1 (..)) -import Data.HashMap.Strict (HashMap) -import Data.HashMap.Strict qualified as HashMap -import Data.HashSet (HashSet) -import Data.HashSet qualified as HashSet (singleton, toList, union, unions) -import Data.Hashable (Hashable (..)) -import Data.List (sortBy) -import Data.List.NonEmpty (NonEmpty (..)) -import Data.Map qualified as Map -import Data.Maybe (fromMaybe, mapMaybe) -import Data.Traversable (for) -import GHC.Generics (Generic) -import Vehicle.Backend.Queries.QuerySetStructure (UnreducedAssertion) -import Vehicle.Backend.Queries.Variable (MixedVariable (..), MixedVariables (..), NetworkVariable (..), NetworkVariableCtx, UserVariableCtx, mixedVariableDBCtx, pattern VFiniteQuantifier) -import Vehicle.Compile.Error -import Vehicle.Compile.ExpandResources.Core -import Vehicle.Compile.Prelude -import Vehicle.Compile.Print (prettyFriendly, prettyVerbose) -import Vehicle.Compile.Resource -import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BooleanExpr (BooleanExpr (..), DisjunctAll (..)) -import Vehicle.Data.BuiltinInterface -import Vehicle.Data.Hashing () -import Vehicle.Data.NormalisedExpr -import Vehicle.Libraries.StandardLibrary.Definitions (StdLibFunction (..)) -import Vehicle.Verify.Core - --- | Okay so this is a wild ride. The Marabou query format has special variable --- names for input and output variables, namely x1 ... xN and y1 ... yM but --- otherwise has the standard SMTLib syntax. We refer to these variables as --- "network IO variables". --- --- This means that in theory you can only reason about a single network applied --- to a single input per property. We get around this restriction by combining --- multiple networks, or multiple applications of the same network into a --- single "meta" network. --- --- This function converts all user quantified variables to network I/O --- variables, converting to DNF as minimally required so that there's a --- consistent set of network applications within a single disjunct and returns: --- - the ordered list of network applications --- - the network variables --- - the expressions that contain those network applications --- - the final expression. -replaceNetworkApplications :: - (MonadCompile m) => - DeclProvenance -> - NetworkContext -> - UserVariableCtx -> - BooleanExpr UnreducedAssertion -> - m (DisjunctAll MetaNetworkPartition) -replaceNetworkApplications declProv networkCtx userVariables boolExpr = do - logCompilerPass MidDetail "network input/output variable insertion" $ do - -- let conjunctsDoc = prettyFriendly (WithContext boolExpr revUserVarCtx) - -- logDebug MaxDetail $ "Initial conjunctions:" <> line <> indent 2 conjunctsDoc <> line - - let ctx = NetworkReaderCtx networkCtx userVariables - flip runReaderT ctx $ do - partitions <- partitionApplications boolExpr - let numberOfPartitions = pretty (length partitions) - logDebug MinDetail $ line <> "Found" <+> numberOfPartitions <+> "meta-network partition(s)" <> line - - let sortedPartitions = sortBy (\a b -> compareApplicationForest (fst a) (fst b)) $ HashMap.toList partitions - case zip [1 ..] sortedPartitions of - [] -> throwError $ NoNetworkUsedInProperty declProv - x : xs -> do - substPartitions <- for (x :| xs) replaceApplications - return $ DisjunctAll substPartitions - --------------------------------------------------------------------------------- --- Generic traversal of network applications - -type MonadTraverseApplications m = - ( MonadCompile m, - MonadReader NetworkReaderCtx m - ) - -data NetworkReaderCtx = NetworkReaderCtx - { networkContext :: NetworkContext, - userVariables :: UserVariableCtx - } - --------------------------------------------------------------------------------- --- Partioning - -type NetworkApplication = (Name, WHNFSpine Builtin) - -applicationExpr :: NetworkApplication -> WHNFValue Builtin -applicationExpr (networkName, spine) = VFreeVar (Identifier User networkName) spine - --- | A tree of network applications that are contained within one another. e.g. --- if `f`, `g` and `h` are networks then `f (g x + h y)` would be --- `Node (f (g x + h y)) {Node (g x) {}, Node (h y) {}}`. The reason we use sets --- at the nodes is that we want them to be invariant to the order of their --- branches. -data NetworkApplicationTree = Node - { nodeApp :: NetworkApplication, - nodeSubApps :: NetworkApplicationForest - } - deriving (Eq, Generic, Hashable) - -type NetworkApplicationForest = HashSet NetworkApplicationTree - --- | Compares two application trees. This could be done via implementing Ord --- but it gets messy fast. In particular `WHNFValue` refers back to normal expressions --- via lambda expressions and then you have to push it through *everywhere* --- even though lambdas will never appear. Better to just implement it locally --- here. -compareApplicationTree :: NetworkApplicationTree -> NetworkApplicationTree -> Ordering -compareApplicationTree a b = do - let (f, x) = nodeApp a - let (g, y) = nodeApp b - compare f g <> compareSpine x y - where - compareSpine :: WHNFSpine Builtin -> WHNFSpine Builtin -> Ordering - compareSpine x y = liftCompare compareValue (mapMaybe getExplicitArg x) (mapMaybe getExplicitArg y) - - compareValue :: WHNFValue Builtin -> WHNFValue Builtin -> Ordering - compareValue x y = case (x, y) of - (VBoundVar v1 spine1, VBoundVar v2 spine2) -> compare v1 v2 <> compareSpine spine1 spine2 - (VBoundVar {}, _) -> LT - (_, VBoundVar {}) -> GT - (VBuiltin b1 spine1, VBuiltin b2 spine2) -> compare b1 b2 <> compareSpine spine1 spine2 - (VBuiltin {}, _) -> LT - (_, VBuiltin {}) -> GT - (VFreeVar i1 spine1, VFreeVar i2 spine2) -> compare i1 i2 <> compareSpine spine1 spine2 - _ -> EQ - -sortApplicationForest :: NetworkApplicationForest -> [NetworkApplicationTree] -sortApplicationForest = sortBy compareApplicationTree . HashSet.toList - -compareApplicationForest :: NetworkApplicationForest -> NetworkApplicationForest -> Ordering -compareApplicationForest a b = do - let aApps = sortApplicationForest a - let bApps = sortApplicationForest b - liftCompare compareApplicationTree aApps bApps - --- | Locate network applications and lift disjunctions as required to form --- consistent partitions. --- --- INVARIANT: All (NetworkApplicationForest, BooleanExpr) pairs within --- within the map should have the property that the `booleanExpr` --- is consistent with respect to the NetworkApplicationForest. -partitionApplications :: - forall m. - (MonadTraverseApplications m) => - BooleanExpr UnreducedAssertion -> - m (HashMap NetworkApplicationForest (BooleanExpr UnreducedAssertion)) -partitionApplications = go - where - go :: - BooleanExpr UnreducedAssertion -> - m (HashMap NetworkApplicationForest (BooleanExpr UnreducedAssertion)) - go = \case - Query assertion -> do - forest <- findApplicationsInExpr assertion - return $ HashMap.singleton forest (Query assertion) - Conjunct e1 e2 -> do - -- Cartesian product r1 and r2, unioning the two states, then we need find duplicate - -- states and then internally conjunct their corresponding boolean expressions. - r1 <- HashMap.toList <$> go e1 - r2 <- HashMap.toList <$> go e2 - let xs = [(HashSet.union apps1 app2, Conjunct expr1 expr2) | (apps1, expr1) <- r1, (app2, expr2) <- r2] - return $ HashMap.fromListWith Conjunct xs - Disjunct e1 e2 -> do - -- Union r1 and r2 and find duplicates states and then internally - -- disjunct their corresponding boolean expressions. - r1 <- go e1 - r2 <- go e2 - return $ HashMap.unionWith Disjunct r1 r2 - -findApplicationsInExpr :: - (MonadTraverseApplications m) => - WHNFValue Builtin -> - m NetworkApplicationForest -findApplicationsInExpr expr = case expr of - VUniverse {} -> unexpectedTypeInExprError currentPass "Universe" - VPi {} -> unexpectedTypeInExprError currentPass "Pi" - VMeta {} -> normalisationError currentPass "Lam" - VLam {} -> normalisationError currentPass "Lam" - VBoundVar _v spine -> findApplicationsInSpine spine - VBuiltin _b spine -> findApplicationsInSpine spine - -- By construction, finite quantifiers are not left in if they contain - -- references to a neural network. - VFiniteQuantifier {} -> return mempty - VFreeVar ident spine -> do - spineForest <- findApplicationsInSpine spine - NetworkReaderCtx {..} <- ask - if nameOf ident `Map.notMember` networkContext - then return spineForest - else return $ HashSet.singleton (Node (nameOf ident, spine) spineForest) - -findApplicationsInSpine :: - (MonadTraverseApplications m) => - WHNFSpine Builtin -> - m NetworkApplicationForest -findApplicationsInSpine spine = - HashSet.unions <$> traverse (findApplicationsInExpr . argExpr) spine - --------------------------------------------------------------------------------- --- Replace network applications. - -data MetaNetworkPartition = MetaNetworkPartition - { metaNetwork :: MetaNetwork, - networkVars :: NetworkVariableCtx, - networkNormSteps :: VariableNormalisationSteps, - partitionExpr :: BooleanExpr UnreducedAssertion - } - -type MetaNetworkVariableSubstitution = HashMap NetworkApplication (WHNFValue Builtin) - -replaceApplications :: - (MonadTraverseApplications m) => - (Int, (NetworkApplicationForest, BooleanExpr UnreducedAssertion)) -> - m MetaNetworkPartition -replaceApplications (partitionID, (applications, expr)) = do - let sectionDoc = "variable substitution for meta-network partition" <+> pretty partitionID - logCompilerPass MaxDetail sectionDoc $ do - appInfo <- flip evalStateT mempty $ lineariseNetworkApplicationForest mempty applications - NetworkReaderCtx {..} <- ask - - -- Calculate the meta network and the network norm steps - let metaNetwork = fmap (\(_, (_, _, _, metaNetworkEntry)) -> metaNetworkEntry) appInfo - let networkVariables = getNetworkContext appInfo - let networkNormSteps = fmap (Introduce . NetworkVar) networkVariables - - -- Substitute the applications in the original expression for the output variables - let outputVariableMap = getOutputVarSubsitution appInfo - networkFreeExpr <- traverse (replaceApplicationsInExpr outputVariableMap) expr - - -- Add the set of input equalities to the boolean expression - let inputEqualities = fmap (\(_, (inputEquality, _, _, _)) -> inputEquality) appInfo - let finalBoolExpr = foldr (Conjunct . Query) networkFreeExpr (reverse inputEqualities) - - logDebug MaxDetail $ - "Final variables:" <+> pretty (fmap NetworkVar networkVariables <> fmap UserVar userVariables) - - logDebug MaxDetail $ - "Final expression:" <+> prettyFriendly (WithContext finalBoolExpr (mixedVariableDBCtx (MixedVariables userVariables networkVariables))) - - return $ - MetaNetworkPartition - { metaNetwork = metaNetwork, - networkVars = networkVariables, - networkNormSteps = networkNormSteps, - partitionExpr = finalBoolExpr - } - -type NetworkAppInfo = - ( UnreducedAssertion, - WHNFValue Builtin, - [NetworkVariable], - MetaNetworkEntry - ) - -lineariseNetworkApplicationForest :: - (MonadTraverseApplications m, MonadState (HashMap Name Int) m) => - [(NetworkApplication, NetworkAppInfo)] -> - NetworkApplicationForest -> - m [(NetworkApplication, NetworkAppInfo)] -lineariseNetworkApplicationForest appInfo forest = do - let linearised = sortApplicationForest forest - foldlM lineariseNetworkApplicationTree appInfo linearised - -lineariseNetworkApplicationTree :: - (MonadTraverseApplications m, MonadState (HashMap Name Int) m) => - [(NetworkApplication, NetworkAppInfo)] -> - NetworkApplicationTree -> - m [(NetworkApplication, NetworkAppInfo)] -lineariseNetworkApplicationTree appInfo (Node app branches) = do - branchInfo <- lineariseNetworkApplicationForest appInfo branches - info <- getNetworkApplicationInfo app branchInfo - return $ info : branchInfo - -getNetworkApplicationInfo :: - (MonadTraverseApplications m, MonadState (HashMap Name Int) m) => - NetworkApplication -> - [(NetworkApplication, NetworkAppInfo)] -> - m (NetworkApplication, NetworkAppInfo) -getNetworkApplicationInfo originalApp@(networkName, originalSpine) subAppInfo = do - NetworkReaderCtx {..} <- ask - let originalBoundCtx = mixedVariableDBCtx (MixedVariables userVariables mempty) - let appDoc = prettyFriendly (WithContext (applicationExpr originalApp) originalBoundCtx) - logCompilerPass MaxDetail ("processing network application:" <+> appDoc) $ do - -- Update the number of times this particular network occurs - seenApplications <- get - let appID = sum seenApplications - networkApplicationCount <- gets (fromMaybe 0 <$> HashMap.lookup networkName) - modify (HashMap.insertWith (+) networkName 1) - - -- Use the applications inside the spine to calculate the updated spine for this application. - let subst = getOutputVarSubsitution subAppInfo - updatedSpine <- replaceApplicationsInSpine subst originalSpine - let updatedApp = (networkName, updatedSpine) - - -- Create the input and output variable - let numUserVars = length userVariables - arg <- getNetworkApplicationArg updatedApp - let mkVar j = VBoundVar (Lv (numUserVars + j)) [] - let inputVar = mkVar (2 * appID) - let outputVar = mkVar (2 * appID + 1) - - -- Create the corresponding network variables - (networkFile, networkType) <- getNetworkDetailsFromCtx networkContext networkName - let inputDimensions = dimensions (inputTensor networkType) - let outputDimensions = dimensions (outputTensor networkType) - let inputNetworkVariable = NetworkVariable networkName networkApplicationCount inputDimensions Input Nothing - let outputNetworkVariable = NetworkVariable networkName networkApplicationCount outputDimensions Output Nothing - let networkVariables = [outputNetworkVariable, inputNetworkVariable] - - -- Create the input equality - let inputEquality = mkInputVarEqualityExpr inputDimensions (Arg mempty Explicit Relevant inputVar) (Arg mempty Explicit Relevant arg) - - -- Create the meta network entry - let metaNetworkEntry = - MetaNetworkEntry - { metaNetworkEntryName = networkName, - metaNetworkEntryType = networkType, - metaNetworkEntryFilePath = networkFile - } - - let newInfo = (updatedApp, (inputEquality, outputVar, networkVariables, metaNetworkEntry)) - - let newBoundCtx = mixedVariableDBCtx (MixedVariables userVariables (getNetworkContext (newInfo : subAppInfo))) - - let updatedAppDoc = prettyFriendly (WithContext (applicationExpr updatedApp) newBoundCtx) - let inputEqualityDoc = prettyFriendly (WithContext inputEquality newBoundCtx) - let outputVarDoc = prettyFriendly (WithContext outputVar newBoundCtx) - unless (null subAppInfo) $ do - logDebug MaxDetail $ "Simplified network application to:" <+> updatedAppDoc - logDebug MaxDetail $ "Introducing input variable:" <+> pretty inputNetworkVariable <+> parens (prettyVerbose inputVar) - logDebug MaxDetail $ "Introducing output variable:" <+> pretty outputNetworkVariable <+> parens (prettyVerbose outputVar) - logDebug MaxDetail $ "Adding input equality:" <+> inputEqualityDoc - logDebug MaxDetail $ "Replacing" <+> squotes appDoc <+> "with output variable" <+> squotes outputVarDoc - - return newInfo - -getOutputVarSubsitution :: - [(NetworkApplication, NetworkAppInfo)] -> - MetaNetworkVariableSubstitution -getOutputVarSubsitution applications = - HashMap.fromList (fmap (second (\(_, outputVar, _, _) -> outputVar)) applications) - -getNetworkContext :: - [(NetworkApplication, NetworkAppInfo)] -> - NetworkVariableCtx -getNetworkContext = concatMap (\(_, (_, _, networkVars, _)) -> networkVars) - -getNetworkApplicationArg :: (MonadCompile m) => NetworkApplication -> m (WHNFValue Builtin) -getNetworkApplicationArg (networkName, spine) = case spine of - [RelevantExplicitArg _ arg] -> return arg - _ -> - compilerDeveloperError $ - "Network" <+> quotePretty networkName <+> "does not seem to have a single explicit argument." - -getNetworkDetailsFromCtx :: (MonadCompile m) => NetworkContext -> Name -> m (FilePath, NetworkType) -getNetworkDetailsFromCtx networkCtx name = do - case Map.lookup name networkCtx of - Just details -> return details - Nothing -> - compilerDeveloperError $ - "Either" <+> quotePretty name <+> "is not a network or it is not in scope" - -mkInputVarEqualityExpr :: - TensorDimensions -> - WHNFArg Builtin -> - WHNFArg Builtin -> - WHNFValue Builtin -mkInputVarEqualityExpr dimensions e1 e2 = do - mkVectorEquality (fmap VNatLiteral dimensions) [e1, e2] - where - -- Would definitely be nicer to somehow reuse the type-class resolution machinary here, - -- but it seems incredibly complicated to setup... - mkVectorEquality :: [WHNFValue Builtin] -> WHNFSpine Builtin -> WHNFValue Builtin - mkVectorEquality dims spine = - let p = mempty - in case dims of - [] -> VBuiltinFunction (Equals EqRat Eq) spine - d : ds -> VFreeVar (identifierOf StdEqualsVector) (nonExplicitArgs <> spine) - where - tensorType = foldr (\dim t -> mkVVectorType t dim) VRatType ds - nonExplicitArgs = - [ Arg p (Implicit True) Relevant tensorType, - Arg p (Implicit True) Relevant tensorType, - Arg p (Implicit True) Irrelevant d, - Arg p (Instance True) Relevant (mkVectorEquality ds []) - ] - -replaceApplicationsInExpr :: - (MonadTraverseApplications m) => - MetaNetworkVariableSubstitution -> - WHNFValue Builtin -> - m (WHNFValue Builtin) -replaceApplicationsInExpr subst expr = case expr of - VUniverse {} -> unexpectedTypeInExprError currentPass "Universe" - VPi {} -> unexpectedTypeInExprError currentPass "Pi" - VMeta {} -> normalisationError currentPass "Lam" - VLam {} -> normalisationError currentPass "Lam" - VBoundVar v spine -> VBoundVar v <$> replaceApplicationsInSpine subst spine - VBuiltin b spine -> VBuiltin b <$> replaceApplicationsInSpine subst spine - -- By construction, finite quantifiers are not left in if they contain - -- references to a neural network. - VFiniteQuantifier {} -> return expr - VFreeVar ident spine -> do - NetworkReaderCtx {..} <- ask - spine' <- replaceApplicationsInSpine subst spine - if nameOf ident `Map.notMember` networkContext - then return $ VFreeVar ident spine' - else replaceApplication subst (nameOf ident, spine') - -replaceApplicationsInSpine :: - (MonadTraverseApplications m) => - MetaNetworkVariableSubstitution -> - WHNFSpine Builtin -> - m (WHNFSpine Builtin) -replaceApplicationsInSpine subst = - traverse (traverse (replaceApplicationsInExpr subst)) - -replaceApplication :: - forall m. - (MonadTraverseApplications m) => - MetaNetworkVariableSubstitution -> - NetworkApplication -> - m (WHNFValue Builtin) -replaceApplication subst app = do - let expr = applicationExpr app - case HashMap.lookup app subst of - Just output -> return output - Nothing -> do - let appDoc = prettyVerbose expr - compilerDeveloperError $ "Unable to find network application" <+> appDoc - -currentPass :: Doc a -currentPass = "insertion of magic network variables" diff --git a/vehicle/src/Vehicle/Backend/Queries/PostProcessing.hs b/vehicle/src/Vehicle/Backend/Queries/PostProcessing.hs new file mode 100644 index 000000000..b2d591233 --- /dev/null +++ b/vehicle/src/Vehicle/Backend/Queries/PostProcessing.hs @@ -0,0 +1,345 @@ +module Vehicle.Backend.Queries.PostProcessing + ( convertPartitionsToQueries, + compileQueryToFormat, + ) +where + +import Control.Monad (foldM, forM, unless, when) +import Control.Monad.Reader (MonadReader (..)) +import Data.Either (partitionEithers) +import Data.LinkedHashMap qualified as LinkedHashMap +import Data.List.NonEmpty (NonEmpty (..)) +import Data.List.NonEmpty qualified as NonEmpty +import Data.Map (Map) +import Data.Map qualified as Map +import Data.Set (Set) +import Data.Set qualified as Set +import Data.Tuple (swap) +import Vehicle.Backend.Queries.UserVariableElimination.Core +import Vehicle.Compile.Error +import Vehicle.Compile.Prelude +import Vehicle.Data.BooleanExpr +import Vehicle.Data.LinearExpr +import Vehicle.Prelude.Warning (CompileWarning (..)) +import Vehicle.Syntax.Builtin +import Vehicle.Verify.Core +import Vehicle.Verify.QueryFormat (QueryFormat (..), QueryFormatID (..), queryFormatID) +import Vehicle.Verify.Specification (QueryMetaData (QueryMetaData)) +import Vehicle.Verify.Variable + +-------------------------------------------------------------------------------- +-- Main entry point + +convertPartitionsToQueries :: + (MonadPropertyStructure m) => + GlobalCtx -> + Partitions -> + m (DisjunctAll (MetaNetwork, UserVariableReconstruction, QueryContents)) +convertPartitionsToQueries globalCtx partitions = do + allQueries <- forM (partitionsToDisjuncts partitions) $ \(userVarSol, assertionTree) -> do + networkVarAssertions <- convertToNetworkRatVarAssertions globalCtx assertionTree + let dnfTree = exprToDNF networkVarAssertions + forM dnfTree $ \conjuncts -> do + -- Calculate meta network + (metaNetwork, newConjuncts) <- calculateMetaNetwork globalCtx conjuncts + -- Compile queries to particular format + let contents = prettifyQueryContents (variables metaNetwork) newConjuncts + -- Return the result + return (metaNetwork, userVarSol, contents) + return $ disjunctDisjuncts allQueries + +-- This is separated from `convertPartitionsToQueries` above because for +-- performance reasons we don't want `MonadSupply` to be needed everywhere. +compileQueryToFormat :: + (MonadPropertyStructure m, MonadSupply QueryID m) => + (MetaNetwork, UserVariableReconstruction, QueryContents) -> + m (QueryMetaData, QueryText) +compileQueryToFormat (metaNetwork, userVars, contents@QueryContents {..}) = do + -- Calculate query address + PropertyMetaData {..} <- ask + queryID <- demand + let queryAddress = (propertyAddress, queryID) + checkIfNetworkInputsBounded queryAddress metaNetwork queryAssertions + let queryMetaData = QueryMetaData queryAddress metaNetwork userVars + queryText <- formatQuery queryFormat queryAddress contents + return (queryMetaData, queryText) + +-------------------------------------------------------------------------------- +-- Step 1: Reduce tensor equalities to a series of rational equalities and +-- checks that the expression only contains network variables. + +convertToNetworkRatVarAssertions :: + forall m. + (MonadCompile m) => + GlobalCtx -> + AssertionTree -> + m (BooleanExpr QueryAssertion) +convertToNetworkRatVarAssertions globalCtx = go + where + go :: BooleanExpr Assertion -> m (BooleanExpr QueryAssertion) + go = \case + Query x -> convert x + Disjunct xs -> Disjunct <$> traverse go xs + Conjunct xs -> Conjunct <$> traverse go xs + + convert :: Assertion -> m (BooleanExpr QueryAssertion) + convert = \case + TensorEq tensorEquality -> do + rationalEqualities <- reduceTensorEquality globalCtx tensorEquality + let assertions = fmap (Query . RationalEq) rationalEqualities + go $ Conjunct $ ConjunctAll (NonEmpty.fromList assertions) + RationalEq (RationalEquality expr) -> + Query <$> makeQueryAssertion Equal expr + RationalIneq (RationalInequality strict expr) -> do + let rel = if strict == Strict then LessThan else LessThanOrEqual + Query <$> makeQueryAssertion rel expr + +makeQueryAssertion :: + (MonadCompile m) => + Relation -> + LinearExpr RationalVariable Rational -> + m QueryAssertion +makeQueryAssertion relation (Sparse coefficients constant) = do + let finalRelation = case relation of + Equal -> EqualRel + LessThan -> OrderRel Lt + LessThanOrEqual -> OrderRel Le + + let rationalVarCoefs = swap <$> Map.toList coefficients + let (userVarCoefs, networkVarCoefs) = partitionEithers (fmap splitRationalVar rationalVarCoefs) + + unless (null userVarCoefs) $ + compilerDeveloperError $ + "Found unsolved user variables" <+> pretty (fmap snd userVarCoefs) + + finalLHS <- case networkVarCoefs of + (c : cs) -> return $ c :| cs + [] -> compilerDeveloperError "Found trivial assertion" + + let finalRHS = -constant + + return $ + QueryAssertion + { lhs = finalLHS, + rel = finalRelation, + rhs = finalRHS + } + +splitRationalVar :: + (Coefficient, RationalVariable) -> + Either (Coefficient, UserRationalVariable) (Coefficient, NetworkRationalVariable) +splitRationalVar (c, var) = case var of + UserRationalVar v -> Left (c, v) + NetworkRationalVar v -> Right (c, v) + +-------------------------------------------------------------------------------- +-- Step 3: calculate the actual set of network applications involved + +data ReindexingState = ReindexingState + { inputOutputIndices :: (Int, Int), + oldVarSubstitution :: Map NetworkRationalVariable NetworkRationalVariable, + metaNetworkEntries :: MetaNetwork + } + +calculateMetaNetwork :: + forall m f. + (MonadCompile m, Traversable f) => + GlobalCtx -> + f QueryAssertion -> + m (MetaNetwork, f QueryAssertion) +calculateMetaNetwork ctx queries = do + -- First calculate the set of network applications actually used in the query + let referencedVars = foldMap queryAssertionVariables queries + let networkApps = snd <$> LinkedHashMap.toList (networkApplications ctx) + let usedNetworkApps = filter (isApplicationUsed referencedVars) networkApps + -- Then perform the reindexing step to fix the indexing of the embedding variables. + let initialState = ReindexingState (0, 0) mempty (MetaNetwork mempty mempty) + finalState <- foldM reindex initialState usedNetworkApps + reindexedQueries <- traverse (substAssertionVars (oldVarSubstitution finalState)) queries + -- Return the final meta network and the reindexedQueries + return (metaNetworkEntries finalState, reindexedQueries) + where + isApplicationUsed :: + Set NetworkRationalVariable -> + NetworkApplicationReplacement -> + Bool + isApplicationUsed referencedVars app = do + let appVars = Set.fromList (inputRationalVars app <> outputRationalVars app) + not $ Set.disjoint referencedVars appVars + + reindex :: ReindexingState -> NetworkApplicationReplacement -> m ReindexingState + reindex ReindexingState {..} NetworkApplicationReplacement {..} = do + let (inputIndex, outputIndex) = inputOutputIndices + let MetaNetwork entries vars = metaNetworkEntries + + -- Calculate the reindexed variables + let reindexedInputVars = fmap (reindexVar inputIndex) inputRationalVars + let reindexedOutputVars = fmap (reindexVar outputIndex) outputRationalVars + let reindexedVars = reindexedInputVars <> reindexedOutputVars + + -- Calculate substitution + let newSubst = Map.fromList (zip inputRationalVars reindexedInputVars <> zip outputRationalVars reindexedOutputVars) + + -- Calculate new entry + let entry = MetaNetworkEntry (fst networkApp) networkInfo + + return $ + ReindexingState + { inputOutputIndices = (inputIndex + length inputRationalVars, outputIndex + length outputRationalVars), + oldVarSubstitution = newSubst <> oldVarSubstitution, + metaNetworkEntries = MetaNetwork (entries <> [entry]) (vars <> reindexedVars) + } + + reindexVar :: Int -> NetworkRationalVariable -> NetworkRationalVariable + reindexVar startIndex (ReducedVariable {originalVar = OriginalNetworkVariable {..}, ..}) = + ReducedVariable + { originalVar = + OriginalNetworkVariable + { startingIndex = startIndex, + .. + }, + .. + } + + substAssertionVars :: Map NetworkRationalVariable NetworkRationalVariable -> QueryAssertion -> m QueryAssertion + substAssertionVars subst QueryAssertion {..} = do + newLHS <- traverse (\(c, v) -> (c,) <$> substVar v) lhs + return $ QueryAssertion {lhs = newLHS, ..} + where + substVar :: NetworkRationalVariable -> m NetworkRationalVariable + substVar var = case Map.lookup var subst of + Nothing -> compilerDeveloperError "Malformed network variable subsitution" + Just newVar -> return newVar + +-------------------------------------------------------------------------------- +-- Step 4: query assertions + +-- | Checks for presence of under-constrained input variables. +checkIfNetworkInputsBounded :: + (MonadCompile m, MonadReader PropertyMetaData m) => + QueryAddress -> + MetaNetwork -> + ConjunctAll QueryAssertion -> + m () +checkIfNetworkInputsBounded queryAddress metaNetwork constraints = do + PropertyMetaData {..} <- ask + let inputVariables = filter (\var -> inputOrOutput (originalVar var) == Input) (variables metaNetwork) + finalStatuses <- variableConstraintStatus inputVariables constraints + logDebug MaxDetail $ pretty constraints + logDebug MaxDetail $ prettyMap finalStatuses + + -- If Marabou, then warn if all inputs are constant. + -- See https://github.com/NeuralNetworkVerification/Marabou/issues/670 + let format = queryFormatID queryFormat + when (format == MarabouQueries && all (== Constant) finalStatuses) $ + logWarning $ + AllConstantNetworkInputVars (queryFormatID queryFormat) queryAddress + + -- Check if all inputs are well-specified. + let unboundedVariables = Map.toList $ Map.mapMaybe toUnderConstrainedStatus finalStatuses + unless (null unboundedVariables) $ + logWarning $ + UnboundedNetworkInputVariables (queryFormatID queryFormat) queryAddress metaNetwork unboundedVariables + +-- | How the value of a particular value of a variable is constrained. +data VariableConstraintStatus + = UnderConstrained UnderConstrainedVariableStatus + | Bounded + | Constant + deriving (Show, Eq) + +instance Pretty VariableConstraintStatus where + pretty = \case + UnderConstrained s -> pretty s + Bounded -> "Bounded" + Constant -> "Constant" + +instance Semigroup VariableConstraintStatus where + UnderConstrained r <> UnderConstrained s = case (r, s) of + (BoundedBelow, BoundedAbove) -> Bounded + (BoundedAbove, BoundedBelow) -> Bounded + _ -> UnderConstrained (r <> s) + UnderConstrained {} <> r = r + r <> UnderConstrained {} = r + Bounded <> r = r + r <> Bounded = r + Constant <> Constant = Constant + +toUnderConstrainedStatus :: VariableConstraintStatus -> Maybe UnderConstrainedVariableStatus +toUnderConstrainedStatus = \case + UnderConstrained s -> Just s + _ -> Nothing + +variableConstraintStatus :: + (MonadCompile m) => + [NetworkRationalVariable] -> + ConjunctAll QueryAssertion -> + m (Map NetworkRationalVariable VariableConstraintStatus) +variableConstraintStatus variables constraints = do + let initialStatus = Map.fromList (fmap (,UnderConstrained Unconstrained) variables) + return $ foldr updateStatuses initialStatus constraints + where + updateStatuses :: + QueryAssertion -> + Map NetworkRationalVariable VariableConstraintStatus -> + Map NetworkRationalVariable VariableConstraintStatus + updateStatuses assertion statuses = case lhs assertion of + (c, v) :| [] | inputOrOutput (originalVar v) == Input -> do + let status = case rel assertion of + EqualRel -> Constant + OrderRel op + | (c >= 0) `xor` (op == Le || op == Lt) -> UnderConstrained BoundedBelow + | otherwise -> UnderConstrained BoundedAbove + Map.insertWith (<>) v status statuses + _ -> statuses + +-------------------------------------------------------------------------------- +-- Step 5: prettyify assertions + +prettifyQueryContents :: + GenericBoundCtx NetworkRationalVariable -> + ConjunctAll QueryAssertion -> + QueryContents +prettifyQueryContents ctx conjuncts = do + let optimisedConjuncts = fmap optimiseAssertionReadability conjuncts + let sortedConjuncts = ConjunctAll $ NonEmpty.sortBy compareAssertion (unConjunctAll optimisedConjuncts) + QueryContents ctx sortedConjuncts + +-- | Applies various optimisations to an assertion to improve readability: +optimiseAssertionReadability :: QueryAssertion -> QueryAssertion +optimiseAssertionReadability (QueryAssertion lhs rel rhs) = do + -- Sort the coefficients, first by input/output status and then by index + let getKey (_, var) = (inputOrOutput (originalVar var), tensorIndices var) + let sortedLHS = NonEmpty.sortWith getKey lhs + + -- Make the properties a tiny bit nicer by checking if all the vars are + -- negative and if so negating everything. + let allCoefficientsNegative = all (\(c, _) -> c < 0) sortedLHS + let (finalLHS, finalRel, finalRHS) = + if not allCoefficientsNegative + then (sortedLHS, rel, rhs) + else do + let negCoeffNames = fmap (\(c, v) -> (-c, v)) sortedLHS + let negOp = flipQueryRel rel + let negConstant = -rhs + (negCoeffNames, negOp, negConstant) + + QueryAssertion + { lhs = finalLHS, + rel = finalRel, + rhs = finalRHS + } + +compareAssertion :: QueryAssertion -> QueryAssertion -> Ordering +compareAssertion e1 e2 = + compareExpression (lhs e1) (lhs e2) + `thenCmp` compare (rel e1) (rel e2) + `thenCmp` compare (rhs e1) (rhs e2) + +compareExpression :: + NonEmpty (Coefficient, NetworkRationalVariable) -> + NonEmpty (Coefficient, NetworkRationalVariable) -> + Ordering +compareExpression expr1 expr2 = + compare (length expr1 == 1) (length expr2 == 1) -- Put variable bounds first + `thenCmp` compare (fmap snd expr1) (fmap snd expr2) diff --git a/vehicle/src/Vehicle/Backend/Queries/QuerySetStructure.hs b/vehicle/src/Vehicle/Backend/Queries/QuerySetStructure.hs deleted file mode 100644 index 4d03d78ba..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/QuerySetStructure.hs +++ /dev/null @@ -1,444 +0,0 @@ -module Vehicle.Backend.Queries.QuerySetStructure - ( UnreducedAssertion, - compileSetQueryStructure, - eliminateNot, - whilePreservingOperations, - isVectorEquals, - vectorOperations, - ) -where - -import Control.Monad.Except (MonadError (..)) -import Control.Monad.Reader (MonadReader (..), ReaderT (..)) -import Data.Data (Proxy (..)) -import Data.HashSet qualified as HashSet (fromList, intersection, null) -import Data.Map qualified as Map (keysSet) -import Data.Set (Set) -import Data.Set qualified as Set (fromList, intersection, map, null) -import Vehicle.Backend.Queries.IfElimination (eliminateIfs, unfoldIf) -import Vehicle.Backend.Queries.LinearExpr (UnreducedAssertion) -import Vehicle.Backend.Queries.UsedFunctions -import Vehicle.Backend.Queries.Variable -import Vehicle.Compile.Context.Free -import Vehicle.Compile.Error -import Vehicle.Compile.ExpandResources.Core -import Vehicle.Compile.Normalise.NBE -import Vehicle.Compile.Prelude -import Vehicle.Compile.Print (prettyFriendly, prettyVerbose) -import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BooleanExpr -import Vehicle.Data.BuiltinInterface -import Vehicle.Data.BuiltinPatterns -import Vehicle.Data.NormalisedExpr -import Vehicle.Libraries.StandardLibrary.Definitions (StdLibFunction (..), findStdLibFunction, fromFiniteQuantifier) -import Vehicle.Verify.Core -import Vehicle.Verify.QueryFormat (QueryFormatID) - --------------------------------------------------------------------------------- --- Main function - --- | Attempts to compile an arbitrary expression of type `Bool` whose top-most --- quantifier is an `exists` down to a set of quantifiers over propositions in --- disjunctive normal form which are guaranteed to not contain if-statements. --- Only reduces quantified variables of `Vector` type as much as is required --- in order to be able to reach DNF. -compileSetQueryStructure :: - (MonadCompile m, MonadFreeContext Builtin m) => - QueryFormatID -> - DeclProvenance -> - UsedFunctionsCtx -> - NetworkContext -> - WHNFValue Builtin -> - m (UserVariableCtx, BooleanExpr UnreducedAssertion, VariableNormalisationSteps) -compileSetQueryStructure queryFormatID declProv queryFreeCtx networkCtx expr = - logCompilerPass MinDetail "compilation of boolean structure" $ do - result <- runReaderT (compileBoolExpr mempty expr) (declProv, queryFreeCtx, networkCtx, queryFormatID) - case result of - Left err -> compilerDeveloperError $ "Something went wrong in query compilation:" <+> pretty err - Right (ctx, boolExpr, steps) -> return (reverse ctx, boolExpr, steps) - --------------------------------------------------------------------------------- --- Data - --- | The set of variables that will be cumulatively in scope at the current --- point in time once all existential quantifiers have been lifted to the --- top level. Essentially the set of quantifiers that are before the current --- point in the tree when traversed depth first. These are ordered in appearance --- order and therefore are *not* a bound context. -type CumulativeCtx = UserVariableCtx - -type RevGlobalCtx = [UserVariable] - -cumulativeVarsToCtx :: CumulativeCtx -> BoundCtx Builtin -cumulativeVarsToCtx = variableCtxToBoundCtx - --- | The only time we should be throwing this error is because we haven't sufficiently --- normalised a user quantified variable above us in the tree, e.g. in the following --- --- forall (xs : Vector Rat 2) . fold and True (map (\x -> x >= 2) xs) --- --- we can't normalise the `map` and hence the `fold` until we normalise the quantified --- variable `xs` to two separate quantifiers. -data TemporaryPropertyError - = CannotEliminateIfs (BoundCtx Builtin) (WHNFValue Builtin) - | CannotEliminateNot (BoundCtx Builtin) (WHNFValue Builtin) - | NonBooleanQueryStructure (BoundCtx Builtin) (WHNFValue Builtin) - deriving (Show) - -instance Pretty TemporaryPropertyError where - pretty = \case - CannotEliminateIfs ctx e -> "CannotEliminateIfs[" <+> prettyFriendly (WithContext e ctx) <+> "]" - CannotEliminateNot ctx e -> "CannotEliminateNot[" <+> prettyFriendly (WithContext e ctx) <+> "]" - NonBooleanQueryStructure ctx e -> "NonBooleanQueryStructure[" <+> prettyFriendly (WithContext e ctx) <+> "]" - -type QueryStructureResult = - Either TemporaryPropertyError (RevGlobalCtx, BooleanExpr UnreducedAssertion, VariableNormalisationSteps) - --- | Pattern matches on a vector equality in the standard library. -isVectorEquals :: - WHNFValue Builtin -> - Maybe (WHNFArg Builtin, WHNFArg Builtin, TensorDimensions) -isVectorEquals = \case - VFreeVar ident args - | ident == identifierOf StdEqualsVector -> case args of - [t1, _t2, dim, _sol, e1, e2] -> do - d <- getNatLiteral $ argExpr dim - ds <- getTensorDimensions $ argExpr t1 - let dims = d : ds - Just (e1, e2, dims) - _ -> Nothing - _ -> Nothing - -getTensorDimensions :: WHNFValue Builtin -> Maybe TensorDimensions -getTensorDimensions = \case - VRatType -> Just [] - VVectorType tElem dim -> do - dims <- getTensorDimensions tElem - d <- getNatLiteral dim - Just $ d : dims - _ -> Nothing - --------------------------------------------------------------------------------- --- Algorithm - -type MonadQueryStructure m = - ( MonadCompile m, - MonadReader (DeclProvenance, UsedFunctionsCtx, NetworkContext, QueryFormatID) m, - MonadFreeContext Builtin m - ) - --- | The set of vector operations that we sometimes want to avoid normalising --- out in the property for efficiency reasons. -vectorOperations :: Set StdLibFunction -vectorOperations = - Set.fromList - [ StdAddVector, - StdSubVector, - StdEqualsVector, - StdNotEqualsVector - ] - --- | The set of finite quantifier operations that we sometimes want to avoid normalising --- out in the property for efficiency reasons. -finiteQuantifierOperations :: Set StdLibFunction -finiteQuantifierOperations = - Set.fromList - [ StdForallIndex, - StdExistsIndex - ] - -vectorLikeOperations :: Set StdLibFunction -vectorLikeOperations = vectorOperations <> finiteQuantifierOperations - --- | Alter the normalisation monads so that builtin vector operations are --- temporarily converted to postulates and therefore do not evaluate. -whilePreservingOperations :: (MonadNorm Builtin m) => Set StdLibFunction -> m a -> m a -whilePreservingOperations funcs = do - let operations = Set.map identifierOf funcs - locallyAdjustCtx (Proxy @Builtin) (alterKeys operations convertToPostulate) - -compileBoolExpr :: - forall m. - (MonadQueryStructure m) => - CumulativeCtx -> - WHNFValue Builtin -> - m QueryStructureResult -compileBoolExpr = go False - where - -- \| Traverses an arbitrary expression of type `Bool`. - go :: Bool -> CumulativeCtx -> WHNFValue Builtin -> m QueryStructureResult - go alreadyLiftedIfs quantifiedVariables expr = - case expr of - ---------------- - -- Base cases -- - ---------------- - VBoolLiteral {} -> - compileAssertion alreadyLiftedIfs quantifiedVariables expr - VBuiltinFunction Equals {} _ -> - compileAssertion alreadyLiftedIfs quantifiedVariables expr - VBuiltinFunction Order {} _ -> - compileAssertion alreadyLiftedIfs quantifiedVariables expr - (isVectorEquals -> Just {}) -> - compileAssertion alreadyLiftedIfs quantifiedVariables expr - --------------------- - -- Recursive cases -- - --------------------- - VBuiltinFunction And [e1, e2] -> - compileOp2 Conjunct alreadyLiftedIfs quantifiedVariables (argExpr e1) (argExpr e2) - VBuiltinFunction Or [e1, e2] -> - compileOp2 Disjunct alreadyLiftedIfs quantifiedVariables (argExpr e1) (argExpr e2) - VBuiltinFunction Not [e] -> - -- As the expression is of type `Bool` we can try lowering the `not` down - -- through the expression. - case eliminateNot (argExpr e) of - Just result -> go alreadyLiftedIfs quantifiedVariables result - Nothing -> do - let err = CannotEliminateNot (cumulativeVarsToCtx quantifiedVariables) expr - return $ Left err - VBuiltinFunction If [_, c, x, y] -> do - -- As the expression is of type `Bool` we can immediately unfold the `if`. - let unfoldedExpr = unfoldIf c (argExpr x) (argExpr y) - go alreadyLiftedIfs quantifiedVariables unfoldedExpr - VInfiniteQuantifier q _ binder env body -> case q of - -- If we're at a `Forall` we know we must have alternating quantifiers. - Forall -> throwError catchableUnsupportedAlternatingQuantifiersError - -- Otherwise try to compile away the quantifier. - Exists -> compileInfiniteQuantifier quantifiedVariables binder env body - VFiniteQuantifier q args binder env body -> - compileFiniteQuantifier quantifiedVariables q args binder env body - ------------ - -- Errors -- - ------------ - _ -> do - let err = NonBooleanQueryStructure (cumulativeVarsToCtx quantifiedVariables) expr - return $ Left err - - compileAssertion :: Bool -> CumulativeCtx -> WHNFValue Builtin -> m QueryStructureResult - compileAssertion alreadyLiftedIfs quantifiedVariables expr - | alreadyLiftedIfs = return $ Right ([], Query expr, []) - | otherwise = do - let ctx = cumulativeVarsToCtx quantifiedVariables - incrCallDepth - ifLessResult <- eliminateIfs expr - result <- case ifLessResult of - Nothing -> - return $ Right ([], Query expr, []) - Just Nothing -> do - let err = CannotEliminateIfs ctx expr - return $ Left err - Just (Just exprWithoutIf) -> do - logDebug MaxDetail $ "If-lifted to:" <+> prettyFriendly (WithContext exprWithoutIf ctx) - let env = variableCtxToEnv quantifiedVariables - normExprWithoutIf <- renormalise env exprWithoutIf - logDebug MaxDetail $ "Normalised to:" <+> prettyFriendly (WithContext normExprWithoutIf ctx) - go True quantifiedVariables normExprWithoutIf - decrCallDepth - return result - - compileOp2 :: - (forall a. BooleanExpr a -> BooleanExpr a -> BooleanExpr a) -> - Bool -> - CumulativeCtx -> - WHNFValue Builtin -> - WHNFValue Builtin -> - m QueryStructureResult - compileOp2 op processingLiftedIfs quantifiedVariables e1 e2 = do - let lhsVariables = quantifiedVariables - lhsResult <- go processingLiftedIfs lhsVariables e1 - case lhsResult of - Left err -> return $ Left err - Right (lhsUserVars, e1', lhsReconstruction) -> do - let rhsVariables = lhsUserVars <> quantifiedVariables - rhsResult <- go processingLiftedIfs rhsVariables e2 - case rhsResult of - Left err -> return $ Left err - Right (rhsUserVars, e2', rhsReconstruction) -> do - let userVars = lhsUserVars <> rhsUserVars - return $ Right (userVars, op e1' e2', lhsReconstruction <> rhsReconstruction) - --- | Constructs a temporary error with no real fields. This should be recaught --- and populated higher up the query compilation process. -catchableUnsupportedAlternatingQuantifiersError :: CompileError -catchableUnsupportedAlternatingQuantifiersError = - UnsupportedAlternatingQuantifiers x x x - where - x = developerError "Evaluating temporary quantifier error" - --------------------------------------------------------------------------------- --- Not elimination - -eliminateNot :: WHNFValue Builtin -> Maybe (WHNFValue Builtin) -eliminateNot arg = case arg of - -- Base cases - VBoolLiteral b -> Just $ VBoolLiteral (not b) - VBuiltinFunction (Order dom ord) args -> Just $ VBuiltinFunction (Order dom (neg ord)) args - VBuiltinFunction (Equals dom eq) args -> Just $ VBuiltinFunction (Equals dom (neg eq)) args - VBuiltinFunction Not [e] -> Just $ argExpr e - -- Inductive cases - VBuiltinFunction Or args -> do - args' <- traverse (traverse eliminateNot) args - return $ VBuiltinFunction And args' - VBuiltinFunction And args -> do - args' <- traverse (traverse eliminateNot) args - return $ VBuiltinFunction Or args' - VBuiltinFunction If [t, c, e1, e2] -> do - e1' <- traverse eliminateNot e1 - e2' <- traverse eliminateNot e2 - return $ VBuiltinFunction If [t, c, e1', e2'] - VFreeVar ident (a : b : n : t : args) -> case findStdLibFunction ident of - Just StdEqualsVector -> do - t' <- traverse eliminateNot t - return $ VFreeVar (identifierOf StdNotEqualsVector) (a : b : n : t' : args) - Just StdNotEqualsVector -> do - t' <- traverse eliminateNot t - return $ VFreeVar (identifierOf StdEqualsVector) (a : b : n : t' : args) - _ -> Nothing - -- Quantifier cases - -- We can't actually lower the `not` throw the body of the quantifier as - -- the body is not yet unnormalised. However, it's fine to stop here as we'll - -- simply continue to normalise it once we re-encounter it again after - -- normalising the quantifier. - VInfiniteQuantifier q args binder env body -> do - let p = mempty - let negatedBody = NotExpr p [Arg p Explicit Relevant body] - Just $ VInfiniteQuantifier (neg q) args binder env negatedBody - VFiniteQuantifier q args binder env body -> do - let p = mempty - let negatedBody = NotExpr p [Arg p Explicit Relevant body] - Just $ VFiniteQuantifier (neg q) args binder env negatedBody - -- Errors - _ -> Nothing - --------------------------------------------------------------------------------- --- Finite quantifier elimination - -compileFiniteQuantifier :: - (MonadQueryStructure m) => - CumulativeCtx -> - Quantifier -> - WHNFSpine Builtin -> - WHNFBinder Builtin -> - WHNFEnv Builtin -> - Expr Ix Builtin -> - m QueryStructureResult -compileFiniteQuantifier quantifiedVariables q quantSpine binder env body = do - canLeaveUnexpanded <- canLeaveFiniteQuantifierUnexpanded env body - if canLeaveUnexpanded - then do - logDebug MidDetail $ "Keeping folded finite quantifier:" <+> pretty q <+> prettyVerbose binder - let foldedExpr = VFiniteQuantifier q quantSpine binder env body - return $ Right (mempty, Query foldedExpr, mempty) - else do - logDebug MaxDetail $ "Unfolding finite quantifier:" <+> pretty q <+> prettyVerbose binder - quantImplementation <- lookupIdentValueInEnv noAbstractFreeVarInterpretation env (fromFiniteQuantifier q) - let quantifierExpr = VFiniteQuantifierSpine quantSpine binder env body - normResult <- - whilePreservingOperations vectorLikeOperations $ - normaliseApp quantImplementation quantifierExpr - compileBoolExpr quantifiedVariables normResult - --- | This is a sound, inexpensive, but incomplete, check for whether --- we can leave the finite quantifier folded as it will only contain --- conjunctions. -canLeaveFiniteQuantifierUnexpanded :: - (MonadQueryStructure m) => - WHNFEnv Builtin -> - Expr Ix Builtin -> - m Bool -canLeaveFiniteQuantifierUnexpanded env expr = do - (_, usedFunctionsCtx, networkCtx, _) <- ask - - let (usedFunctions, usedFreeVars) = getUsedFunctions usedFunctionsCtx (getUsedFunctionsCtx usedFunctionsCtx env) expr - let forbiddenFunctions = - HashSet.fromList - [ Quantifier Exists, - Quantifier Forall - ] - - let doesNotHaveDisjunction = HashSet.null (HashSet.intersection usedFunctions forbiddenFunctions) - let networks = Set.map (Identifier User) (Map.keysSet networkCtx) - let doesNotHaveNetwork = Set.null (Set.intersection usedFreeVars networks) - return $ doesNotHaveDisjunction && doesNotHaveNetwork - --------------------------------------------------------------------------------- --- Infinite quantifier elimination - -compileInfiniteQuantifier :: - (MonadQueryStructure m) => - CumulativeCtx -> - WHNFBinder Builtin -> - WHNFEnv Builtin -> - Expr Ix Builtin -> - m QueryStructureResult -compileInfiniteQuantifier quantifiedVariables binder env body = do - let variableName = getBinderName binder - let variableDoc = "variable" <+> quotePretty variableName - logCompilerPass MidDetail ("compilation of quantified" <+> variableDoc) $ do - let isDuplicateName = any (\v -> userVarName v == variableName) quantifiedVariables - if isDuplicateName - then do - (declProv, _, _, _) <- ask - throwError $ DuplicateQuantifierNames declProv variableName - else do - let currentLevel = Lv $ length quantifiedVariables - tensorDimensions <- calculateVariableDimensions binder - let unnormalisedVar = UserVariable variableName tensorDimensions variableName - - -- First of all optimistically try not to normalise the quantified variable. - let optimisticEnv = extendEnvWithBound binder env - optimisiticBody <- whilePreservingOperations vectorLikeOperations $ normaliseInEnv optimisticEnv body - - let unreducedPassDoc = "Trying without reducing dimensions of" <+> variableDoc - optimisticResult <- - logCompilerSection MidDetail unreducedPassDoc $ - compileBoolExpr (unnormalisedVar : quantifiedVariables) optimisiticBody - - case optimisticResult of - -- If we can compile the structure without normalising then great! - Right (allQuantifiedVariables, substructure, variableReconstruction) -> do - logDebug MidDetail $ "Succeeded without reducing dimensions of" <+> variableDoc - return $ Right (unnormalisedVar : allQuantifiedVariables, substructure, variableReconstruction) - - -- Otherwise we only a hit a temporary error so we try again normalising the - -- user variable more aggressively. - Left e -> do - logDebug MidDetail $ "Failed to compile without reducing dimensions of" <+> variableDoc - logDebug MidDetail $ indent 2 ("Reason:" <+> pretty e) <> line - let (newQuantifiedVariables, envEntry) = reduceVariable currentLevel unnormalisedVar - let newEnv = extendEnvWithDefined envEntry binder env - - let updatedQuantifiedVars = newQuantifiedVariables <> quantifiedVariables - - normBody <- whilePreservingOperations vectorLikeOperations $ normaliseInEnv newEnv body - - let reducedPassDoc = "Compiling while reducing dimensions of" <+> quotePretty variableName - normalisedResult <- - logCompilerSection MidDetail reducedPassDoc $ - compileBoolExpr updatedQuantifiedVars normBody - - case normalisedResult of - Left err -> return $ Left err - Right (subQuantifiedVariables, substructure, varReconstruction) -> do - let normalisationStep = Reduce (UserVar unnormalisedVar) - let allQuantifiedVariables = newQuantifiedVariables <> subQuantifiedVariables - return $ Right (allQuantifiedVariables, substructure, normalisationStep : varReconstruction) - -calculateVariableDimensions :: forall m. (MonadQueryStructure m) => WHNFBinder Builtin -> m TensorDimensions -calculateVariableDimensions binder = go (typeOf binder) - where - go :: WHNFType Builtin -> m TensorDimensions - go = \case - VVectorType tElem (VNatLiteral dim) -> do - dims <- go tElem - return $ dim : dims - t -> goBase t - - goBase :: WHNFType Builtin -> m TensorDimensions - goBase = \case - VRatType {} -> return [] - baseType -> do - (declProv, _, _, queryFormatID) <- ask - let p = provenanceOf binder - let baseName = getBinderName binder - let declIdent = fst declProv - throwError $ UnsupportedVariableType queryFormatID declIdent p baseName baseType (typeOf binder) [BuiltinType Rat] diff --git a/vehicle/src/Vehicle/Backend/Queries/UsedFunctions.hs b/vehicle/src/Vehicle/Backend/Queries/UsedFunctions.hs deleted file mode 100644 index ca5078c19..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/UsedFunctions.hs +++ /dev/null @@ -1,122 +0,0 @@ -module Vehicle.Backend.Queries.UsedFunctions - ( UsedFunctionsCtx, - UsedFunctionsInfo, - getUsedFunctions, - getUsedFunctionsCtx, - ) -where - -import Data.HashSet (HashSet) -import Data.HashSet qualified as HashSet (singleton) -import Data.Map qualified as Map (lookup) -import Data.Maybe (fromMaybe) -import Data.Set (Set) -import Data.Set qualified as Set (singleton) -import Vehicle.Compile.Context.Free -import Vehicle.Compile.Prelude -import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.DeBruijn (dbLevelToIndex) -import Vehicle.Data.NormalisedExpr - --------------------------------------------------------------------------------- --- Builtin and free variable tracking - -type UsedFunctionsCtx = GenericFreeCtx UsedFunctionsInfo - -type UsedFunctionsInfo = (HashSet BuiltinFunction, Set Identifier) - -getUsedFunctions :: - GenericFreeCtx UsedFunctionsInfo -> - GenericBoundCtx UsedFunctionsInfo -> - Expr Ix Builtin -> - UsedFunctionsInfo -getUsedFunctions freeCtx boundCtx expr = case expr of - Universe {} -> mempty - Meta {} -> mempty - Hole {} -> mempty - Pi {} -> mempty - BoundVar _ v -> getUsedVarsBoundVar boundCtx v - Builtin _ b -> getUsedFunctionsBuiltin b - FreeVar _ ident -> getUsedFunctionsFreeVar freeCtx ident - App _ fun args -> foldr ((<>) . getUsedFunctions freeCtx boundCtx . argExpr) (getUsedFunctions freeCtx boundCtx fun) args - Let _ e1 _binder e2 -> getUsedFunctions freeCtx boundCtx e1 <> getUsedFunctions freeCtx boundCtx e2 - Lam _ _binder e -> getUsedFunctions freeCtx (mempty : boundCtx) e - -getUsedNormFunctions :: - GenericFreeCtx UsedFunctionsInfo -> - GenericBoundCtx UsedFunctionsInfo -> - WHNFValue Builtin -> - UsedFunctionsInfo -getUsedNormFunctions freeCtx boundCtx expr = case expr of - VPi {} -> mempty - VUniverse {} -> mempty - VMeta {} -> mempty - VLam _ (WHNFBody env body) -> do - let envInfo = getUsedFunctionsEnv freeCtx boundCtx env - let bodyInfo = getUsedFunctions freeCtx (mempty : boundCtx) body - envInfo <> bodyInfo - VBoundVar v spine -> do - let varInfo = getUsedVarsBoundVar boundCtx (dbLevelToIndex (Lv (length boundCtx)) v) - let spineInfo = getUsedFunctionsSpine freeCtx boundCtx spine - varInfo <> spineInfo - VFreeVar ident spine -> do - let identInfo = getUsedFunctionsFreeVar freeCtx ident - let spineInfo = getUsedFunctionsSpine freeCtx boundCtx spine - identInfo <> spineInfo - VBuiltin b spine -> do - let builtinInfo = getUsedFunctionsBuiltin b - let spineInfo = getUsedFunctionsSpine freeCtx boundCtx spine - builtinInfo <> spineInfo - -getUsedFunctionsBuiltin :: - Builtin -> - UsedFunctionsInfo -getUsedFunctionsBuiltin = \case - BuiltinFunction f -> (HashSet.singleton f, mempty) - _ -> mempty - -getUsedFunctionsFreeVar :: - GenericFreeCtx UsedFunctionsInfo -> - Identifier -> - UsedFunctionsInfo -getUsedFunctionsFreeVar freeCtx ident = - (mempty, Set.singleton ident) <> fromMaybe mempty (Map.lookup ident freeCtx) - -getUsedVarsBoundVar :: - GenericBoundCtx UsedFunctionsInfo -> - Ix -> - UsedFunctionsInfo -getUsedVarsBoundVar boundCtx ix = - fromMaybe mempty (lookupIx boundCtx ix) - -getUsedFunctionsSpine :: - GenericFreeCtx UsedFunctionsInfo -> - GenericBoundCtx UsedFunctionsInfo -> - WHNFSpine Builtin -> - UsedFunctionsInfo -getUsedFunctionsSpine freeCtx boundCtx = - foldMap (getUsedNormFunctions freeCtx boundCtx . argExpr) - -getUsedFunctionsEnv :: - GenericFreeCtx UsedFunctionsInfo -> - GenericBoundCtx UsedFunctionsInfo -> - WHNFEnv Builtin -> - UsedFunctionsInfo -getUsedFunctionsEnv freeCtx boundCtx = - foldMap (getUsedFunctionsEnvEntry freeCtx boundCtx) - -getUsedFunctionsEnvEntry :: - GenericFreeCtx UsedFunctionsInfo -> - GenericBoundCtx UsedFunctionsInfo -> - EnvEntry 'WHNF Builtin -> - UsedFunctionsInfo -getUsedFunctionsEnvEntry freeCtx boundCtx (_binder, value) = case value of - Bound {} -> mempty - Defined v -> getUsedNormFunctions freeCtx boundCtx v - -getUsedFunctionsCtx :: - GenericFreeCtx UsedFunctionsInfo -> - WHNFEnv Builtin -> - GenericBoundCtx UsedFunctionsInfo -getUsedFunctionsCtx freeCtx = - foldr (\u v -> getUsedFunctionsEnvEntry freeCtx v u : v) mempty diff --git a/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination.hs b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination.hs index 800b48504..b7653fbf7 100644 --- a/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination.hs +++ b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination.hs @@ -1,678 +1,372 @@ -{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} - module Vehicle.Backend.Queries.UserVariableElimination ( eliminateUserVariables, - catchableUnsupportedNonLinearConstraint, + UserVariableReconstruction, + UserVariableReconstructionStep (..), ) where --- Need to import this qualified as in GHC 9.6 and above liftA2 is part of Prelude --- and therefore importing it normally gives us an "Unused import warning" on --- 9.6 and above, but not earlier versions. -import Control.Applicative qualified as Applicative (liftA2) +-- Needed as Applicative is exported by Prelude in GHC 9.6 and above. +import Control.Applicative (Applicative (..)) +import Control.Monad (unless, when) import Control.Monad.Except (MonadError (..)) -import Control.Monad.Reader (MonadReader (..), runReaderT) -import Data.Foldable (foldrM) -import Data.IntSet qualified as IntSet -import Data.List (elemIndex, partition) -import Data.Map (Map) -import Data.Map qualified as Map -import Data.Maybe (fromMaybe, mapMaybe) -import Data.Set (Set) -import Data.Set qualified as Set -import Data.Traversable (for) +import Control.Monad.Reader (MonadReader (..)) +import Control.Monad.State (MonadState (..), StateT (..)) +import Control.Monad.Writer (MonadWriter, WriterT (..)) +import Data.Vector (Vector) import Data.Vector qualified as Vector -import Vehicle.Backend.Queries.FourierMotzkinElimination (fourierMotzkinElimination) -import Vehicle.Backend.Queries.GaussianElimination - ( gaussianElimination, - ) -import Vehicle.Backend.Queries.IfElimination (eliminateIfs, unfoldIf) -import Vehicle.Backend.Queries.LinearExpr -import Vehicle.Backend.Queries.QuerySetStructure (eliminateNot, isVectorEquals) -import Vehicle.Backend.Queries.Variable -import Vehicle.Compile.Context.Free (MonadFreeContext) +import Vehicle.Backend.Queries.PostProcessing (convertPartitionsToQueries) +import Vehicle.Backend.Queries.UserVariableElimination.Core +import Vehicle.Backend.Queries.UserVariableElimination.EliminateExists (eliminateExists) +import Vehicle.Backend.Queries.UserVariableElimination.EliminateNot (eliminateNot) +import Vehicle.Backend.Queries.UserVariableElimination.Unblocking (tryUnblockBool) import Vehicle.Compile.Error -import Vehicle.Compile.Normalise.Builtin (evalMul) -import Vehicle.Compile.Normalise.NBE (renormalise) +import Vehicle.Compile.Normalise.NBE import Vehicle.Compile.Prelude -import Vehicle.Compile.Print (prettyVerbose) +import Vehicle.Compile.Print (prettyFriendlyEmptyCtx, prettyVerbose) import Vehicle.Compile.Type.Subsystem.Standard import Vehicle.Data.BooleanExpr -import Vehicle.Data.BuiltinInterface -import Vehicle.Data.DeBruijn +import Vehicle.Data.BuiltinInterface.Value +import Vehicle.Data.LinearExpr (LinearExpr, RationalTensor (..), addExprs, constantExpr, isConstant, scaleExpr, singletonVarExpr, zeroTensor) import Vehicle.Data.NormalisedExpr -import Vehicle.Libraries.StandardLibrary.Definitions (StdLibFunction (..), pattern TensorIdent) -import Vehicle.Prelude.Warning (CompileWarning (ResortingtoFMElimination)) -import Vehicle.Verify.Core - --- | Takes in a set of unreduced user and network variables and a boolean expression --- over those variables, and returns a list of assertions only over the fully reduced --- network variables. -eliminateUserVariables :: - (MonadCompile m, MonadFreeContext Builtin m) => - DeclProvenance -> - MetaNetwork -> - MixedVariables -> - BooleanExpr UnreducedAssertion -> - m (MaybeTrivial (DisjunctAll (CLSTProblem, VariableNormalisationSteps))) -eliminateUserVariables declProvenance metaNetwork variables expr = do - flip runReaderT (declProvenance, metaNetwork) $ do - -- The first step is to try to solve for as many user variables as possible - -- without performing any reduction of any vector variables. - unreducedSolverResult <- tryToSolveForUnreducedUserVariables variables expr - case unreducedSolverResult of - Trivial b -> return $ Trivial b - NonTrivial (vectorVariableSolutions, unsolvableAssertions, unreducedSolutionSteps) -> do - -- We then fully reduce the remaining variables to variables over rationals. - reductionResult <- reduceRemainingVariables variables vectorVariableSolutions unsolvableAssertions - case reductionResult of - Trivial b -> return $ Trivial b - NonTrivial (reducedVariables, reducedUncompiledAssertions, normalisationSteps) -> do - logDebug MaxDetail "Converting to DNF" - let dnfExpr = exprToDNF reducedUncompiledAssertions - case dnfExpr of - Trivial b -> return $ Trivial b - NonTrivial disjuncts -> do - logDebug MaxDetail $ "Found" <+> pretty (length disjuncts) <+> "queries" <> line - results <- for disjuncts $ \conjuncts -> do - -- We then solve for the remaining reduced user variables - (networkVariableAssertions, reducedSolutionSteps) <- - solveForReducedUserVariables reducedVariables conjuncts - - -- Finally we check that the problem is still non-trivial - let maybeAssertions = filterTrivialAssertions networkVariableAssertions - return $ case maybeAssertions of - Nothing -> Trivial False - Just [] -> Trivial True - Just (a : as) -> do - let reconstructionSteps = unreducedSolutionSteps <> normalisationSteps <> reducedSolutionSteps - NonTrivial (CLSTProblem (networkVariableCtx reducedVariables) (a : as), reconstructionSteps) - - return $ eliminateTrivialDisjunctions results - -type MonadSMT m = - ( MonadCompile m, - MonadFreeContext Builtin m, - MonadReader LCSState m - ) - -type LCSState = - ( DeclProvenance, - MetaNetwork - ) +import Vehicle.Libraries.StandardLibrary.Definitions (StdLibFunction (StdEqualsVector, StdNotEqualsVector)) +import Vehicle.Verify.Core (MetaNetwork, QueryContents) +import Vehicle.Verify.QueryFormat (QueryFormat (..), supportsStrictInequalities) +import Vehicle.Verify.Specification +import Vehicle.Verify.Variable +import Prelude hiding (Applicative (..)) -------------------------------------------------------------------------------- --- Solving of unreduced assertions - --- | Solutions for vector-level user variables. They are ordered so that --- earlier solutions may depend on solved variables later in the list. -type UnreducedVariableSolutions = [(UserVariable, WHNFValue Builtin)] +-- Algorithm -type SolvableAssertion = Assertion MixedVariable - --- | Tries to optimistically solve for the user variables in an unreduced state. --- This is not guaranteed to succeed, as higher order functions are not --- guaranteed to be fully reduced and there may still be lookups present. -tryToSolveForUnreducedUserVariables :: - (MonadSMT m) => - MixedVariables -> - BooleanExpr UnreducedAssertion -> - m (MaybeTrivial (UnreducedVariableSolutions, BooleanExpr UnreducedAssertion, VariableNormalisationSteps)) -tryToSolveForUnreducedUserVariables variables expr = - logCompilerPass MidDetail "attempt to solve for unreduced user variables" $ do - logDebug MidDetail $ "There are" <+> pretty (length expr) <+> "assertions..." - - -- Split out the equalities from the inequalities. - (solvableEqualities, remainingExpr) <- extractSolvableVectorEqualities (mixedVariableCtx variables) expr - - logDebug MidDetail $ - "... of which" - <+> pretty (length solvableEqualities) - <+> "are solvable vector equalities." - <> line - - if null solvableEqualities - then return $ NonTrivial (mempty, expr, mempty) - else do - -- Try to solve the solvable equalities using Gaussian elimination. - let userVars = UserVar <$> userVariableCtx variables - (gaussianSolutions, _, usedEqualityIDs) <- - gaussianElimination userVars (fmap (assertionExpr . snd) solvableEqualities) - let gaussianReconstructionSteps = fmap mkGaussianReconstructionStep gaussianSolutions - logDebug MidDetail $ "Eliminated user variables:" <+> pretty (fmap fst gaussianSolutions) - - -- Calculate the updated set of assertions. - let unusedEqualities = filterByIndex (`IntSet.notMember` usedEqualityIDs) (fmap fst solvableEqualities) - let remainingEqualityExpr = case unusedEqualities of - [] -> Nothing - a : as -> Just $ foldr (Conjunct . Query) (Query a) as - let maybeFinalExpr = unionMaybeWith Conjunct remainingEqualityExpr remainingExpr - - case maybeFinalExpr of - Nothing -> return $ Trivial True - Just finalExpr -> - NonTrivial <$> do - -- Substitute the solutions through the remaining set of solutions. - let varsSolved = mapMaybe (\(v, s) -> (,s) <$> getUserVariable v) gaussianSolutions - solutions <- traverse (solutionToExpr (mixedVariableCtx variables)) varsSolved - return (solutions, finalExpr, gaussianReconstructionSteps) - --- | Tries to extract any vector level equalities that are suitable for plugging into --- Gaussian elimination. -extractSolvableVectorEqualities :: +-- | Compiles the top-level structure of a property until it hits the first quantifier. +-- Assumptions - expression is well-typed in the empty context and of type Bool. +eliminateUserVariables :: forall m. - (MonadSMT m) => - MixedVariableCtx -> - BooleanExpr UnreducedAssertion -> - m ([(UnreducedAssertion, SolvableAssertion)], Maybe (BooleanExpr UnreducedAssertion)) -extractSolvableVectorEqualities mixedVariables = go + (MonadPropertyStructure m) => + WHNFValue Builtin -> + m (Property (MetaNetwork, UserVariableReconstruction, QueryContents)) +eliminateUserVariables = go where - go :: - BooleanExpr UnreducedAssertion -> - m ([(UnreducedAssertion, SolvableAssertion)], Maybe (BooleanExpr UnreducedAssertion)) + go :: WHNFValue Builtin -> m (Property (MetaNetwork, UserVariableReconstruction, QueryContents)) go expr = case expr of - -- When we hit a query we need to check if it's actually a solvable vector equality - Query assertion -> case assertion of - (isVectorEquals -> Just (e1, e2, dims)) -> do - maybeSolvableAssertion <- compileVectorEquality mixedVariables dims (argExpr e1) (argExpr e2) - case maybeSolvableAssertion of - Nothing -> return ([], Just (Query assertion)) - Just solvableVectorEquality -> return ([(assertion, solvableVectorEquality)], Nothing) - _ -> do - return ([], Just (Query assertion)) - -- When we hit a conjunction we just recurse into it's branches - Conjunct e1 e2 -> do - (cs1, e1') <- go e1 - (cs2, e2') <- go e2 - return (cs1 <> cs2, unionMaybeWith Conjunct e1' e2') - -- Note when we hit a disjunct we don't proceed any further as the equalities - -- are not universally applicable. One potential future optimisation - -- could be to further convert to DNF here. - Disjunct {} -> - return ([], Just expr) - --- | Converts a Gaussian elimination solution for a user variable back to a --- Vehicle expression. -solutionToExpr :: - (MonadCompile m) => - MixedVariableCtx -> - (UserVariable, SparseLinearExpr MixedVariable) -> - m (UserVariable, WHNFValue Builtin) -solutionToExpr variables (var, Sparse {..}) = do - let findVarIx v = Ix $ fromMaybe (developerError ("Variable" <+> pretty var <+> "not found")) (v `elemIndex` variables) - let toExprVar v = VBoundVar (dbIndexToLevel (Lv $ length variables) (findVarIx v)) [] - let addFn e1 e2 = mkRatVectorAdd (VNatLiteral <$> dimensions) [e1, e2] - let subFn e1 e2 = mkRatVectorSub (VNatLiteral <$> dimensions) [e1, e2] - -- Need to negate the coefficients as we're rearranging the equation. - let combFn (v, c) e - | v == UserVar var = e - | c == 1.0 = subFn e (toExprVar v) - | c == -1.0 = addFn e (toExprVar v) - | otherwise = developerError "Vector equality coefficients should currently all be magnitude 1.0" - let constant = constantExpr dimensions (Vector.map (* (-1)) constantValue) - let varCoeffList = Map.toList coefficients - let expr = foldr combFn constant varCoeffList - return (var, expr) - where - mkTensorType :: WHNFType Builtin -> WHNFType Builtin -> WHNFType Builtin - mkTensorType tElem dims = VFreeVar TensorIdent [Arg mempty Explicit Relevant tElem, Arg mempty Explicit Irrelevant dims] - - mkRatVectorAdd :: [WHNFValue Builtin] -> [WHNFValue Builtin] -> WHNFValue Builtin - mkRatVectorAdd = mkVectorOp (Add AddRat) StdAddVector - - mkRatVectorSub :: [WHNFValue Builtin] -> [WHNFValue Builtin] -> WHNFValue Builtin - mkRatVectorSub = mkVectorOp (Sub SubRat) StdSubVector - - mkVectorOp :: - BuiltinFunction -> - StdLibFunction -> - [WHNFValue Builtin] -> - [WHNFValue Builtin] -> - WHNFValue Builtin - mkVectorOp baseOp libOp dims spine = case dims of - [] -> VBuiltinFunction baseOp (Arg mempty Explicit Relevant <$> spine) - (d : ds) -> - VFreeVar - (identifierOf libOp) - ( [ Arg p (Implicit True) Relevant vecType, - Arg p (Implicit True) Relevant vecType, - Arg p (Implicit True) Relevant vecType, - Arg p (Implicit True) Irrelevant d, - Arg p (Instance True) Relevant (mkVectorOp baseOp libOp ds []) - ] - <> fmap (Arg p Explicit Relevant) spine - ) - where - p = mempty; vecType = mkTensorType VRatType (mkVList ds) - -compileVectorEquality :: - (MonadSMT m) => - MixedVariableCtx -> - TensorDimensions -> - WHNFValue Builtin -> + ---------------- + -- Base cases -- + ---------------- + VBoolLiteral b -> return $ Trivial b + --------------------- + -- Recursive cases -- + --------------------- + VAnd e1 e2 -> andTrivial andBoolExpr <$> go e1 <*> go e2 + VOr e1 e2 -> orTrivial orBoolExpr <$> go e1 <*> go e2 + VIf _ c x y -> go (eliminateIf c x y) + VExists _ binder env body -> compileQuantifiedQuerySet False binder env body + VForall _ binder env body -> do + logDebug MinDetail ("Negating property..." <> line) + compileQuantifiedQuerySet True binder env (negExpr body) + ----------------- + -- Mixed cases -- + ----------------- + -- In the next three cases, we can only fail to unblock these cases because + -- we can't evaluate networks applied to constant arguments. + -- + -- (if (forall x . f x > 0) then x else 0) > 0 + -- + -- When we have that ability then case can be turned to an error. + -- These cases can happen, e.g. + VNot {} -> compileUnquantifiedQuerySet expr + VEqual {} -> compileUnquantifiedQuerySet expr + VNotEqual {} -> compileUnquantifiedQuerySet expr + VOrder {} -> compileUnquantifiedQuerySet expr + VVectorEqual {} -> compileUnquantifiedQuerySet expr + VVectorNotEqual {} -> compileUnquantifiedQuerySet expr + -- This final case can only occur at all because + -- we can't evaluate networks applied to constant arguments. + -- When we have that ability we can replace it with an error. + _ -> compileUnquantifiedQuerySet expr + +compileQuantifiedQuerySet :: + (MonadPropertyStructure m) => + Bool -> + WHNFBinder Builtin -> + WHNFBoundEnv Builtin -> + Expr Ix Builtin -> + m (Property (MetaNetwork, UserVariableReconstruction, QueryContents)) +compileQuantifiedQuerySet isPropertyNegated binder env body = do + let subsectionDoc = "compilation of set of quantified queries:" <+> prettyFriendlyEmptyCtx (VExists [] binder env body) + logCompilerPass MaxDetail subsectionDoc $ do + (maybePartitions, globalCtx) <- runStateT (compileExists binder env body) emptyGlobalCtx + case maybePartitions of + Trivial b -> return $ Trivial (b `xor` isPropertyNegated) + NonTrivial partitions -> do + queries <- convertPartitionsToQueries globalCtx partitions + return $ NonTrivial $ Query $ QuerySet isPropertyNegated queries + +-- | We only need this because we can't evaluate networks in the compiler. +compileUnquantifiedQuerySet :: + (MonadPropertyStructure m) => WHNFValue Builtin -> - m (Maybe SolvableAssertion) -compileVectorEquality variables assertionDims assertionLHS assertionRHS = do - lhsLinExpr <- compilerVectorLinearExpr variables assertionDims assertionLHS - rhsLinExpr <- compilerVectorLinearExpr variables assertionDims assertionRHS - case (lhsLinExpr, rhsLinExpr) of - (Just lhs, Just rhs) -> do - let reducedAssertion = constructReducedAssertion (lhs, Equal, rhs) - return $ Just reducedAssertion - _ -> return Nothing - -compilerVectorLinearExpr :: + m (Property (MetaNetwork, UserVariableReconstruction, QueryContents)) +compileUnquantifiedQuerySet value = do + let subsectionDoc = "compilation of set of unquantified queries:" <+> prettyFriendlyEmptyCtx value + logCompilerPass MaxDetail subsectionDoc $ do + ((maybePartitions, globalCtx), equalities) <- runWriterT (runStateT (compileBoolExpr value) emptyGlobalCtx) + (networkEqPartitions, _) <- runStateT (networkEqualitiesToPartition equalities) globalCtx + let equalitiesPartition = andTrivial andPartitions maybePartitions networkEqPartitions + case equalitiesPartition of + Trivial b -> return $ Trivial b + NonTrivial partitions -> do + queries <- convertPartitionsToQueries globalCtx partitions + return $ NonTrivial $ Query $ QuerySet False queries + +-- | Attempts to compile an arbitrary expression of type `Bool` down to a tree +-- of assertions implicitly existentially quantified by a set of network +-- input/output variables. +compileBoolExpr :: + (MonadQueryStructure m, MonadWriter [WHNFValue QueryBuiltin] m) => + WHNFValue QueryBuiltin -> + m (MaybeTrivial Partitions) +compileBoolExpr expr = case expr of + ---------------- + -- Base cases -- + ---------------- + VBoolLiteral b -> return $ Trivial b + VOrder OrderRat op e1 e2 -> tryUnblockBool expr compileBoolExpr (compileRationalAssertion (ordToAssertion op) e1 e2) + VEqual EqRat e1 e2 -> tryUnblockBool expr compileBoolExpr (compileRationalAssertion eqToAssertion e1 e2) + VVectorEqualFull spine@(VVecEqArgs e1 e2) -> tryUnblockBool expr compileBoolExpr (compileTensorAssertion spine e1 e2) + VForall {} -> throwError catchableUnsupportedAlternatingQuantifiersError + --------------------- + -- Recursive cases -- + --------------------- + VNotEqual EqRat e1 e2 -> compileBoolExpr =<< eliminateNotEqualRat e1 e2 + VVectorNotEqualFull spine -> compileBoolExpr =<< eliminateNotVectorEqual spine + VNot e -> compileBoolExpr =<< eliminateNot e + VIf _ c x y -> compileBoolExpr (eliminateIf c x y) + VAnd x y -> andTrivial andPartitions <$> compileBoolExpr x <*> compileBoolExpr y + VOr x y -> orTrivial orPartitions <$> compileBoolExpr x <*> compileBoolExpr y + VExists _ binder env body -> compileExists binder env body + _ -> tryUnblockBool expr compileBoolExpr (compilerDeveloperError "Could not unblock bool expr") + +eliminateIf :: WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin +eliminateIf c x y = VOr (VAnd c x) (VAnd (VNot c) y) + +eliminateNotEqualRat :: + (MonadQueryStructure m) => + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + m (WHNFValue QueryBuiltin) +eliminateNotEqualRat x y = do + PropertyMetaData {..} <- ask + if supportsStrictInequalities queryFormat + then return $ VOr (VOrder OrderRat Le x y) (VOrder OrderRat Le y x) + else throwError $ UnsupportedInequality (queryFormatID queryFormat) propertyProvenance + +eliminateNotVectorEqual :: + (MonadQueryStructure m) => + WHNFSpine QueryBuiltin -> + m (WHNFValue QueryBuiltin) +eliminateNotVectorEqual = appStdlibDef StdNotEqualsVector + +compileRationalAssertion :: + (MonadQueryStructure m) => + (LinearExpr RationalVariable Rational -> LinearExpr RationalVariable Rational -> Assertion) -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + m (MaybeTrivial Partitions) +compileRationalAssertion mkAssertion x y = do + e1' <- compileRatLinearExpr x + e2' <- compileRatLinearExpr y + return $ mkTrivialPartition (mkAssertion e1' e2') + +compileRatLinearExpr :: forall m. - (MonadSMT m) => - MixedVariableCtx -> - TensorDimensions -> - WHNFValue Builtin -> - m (Maybe (SparseLinearExpr MixedVariable)) -compilerVectorLinearExpr variables dimensions = go + (MonadQueryStructure m) => + WHNFValue QueryBuiltin -> + m (LinearExpr RationalVariable Rational) +compileRatLinearExpr = go where - go :: WHNFValue Builtin -> m (Maybe (SparseLinearExpr MixedVariable)) + go :: WHNFValue QueryBuiltin -> m (LinearExpr RationalVariable Rational) go e = case e of - VBoundVar v [] -> - Just <$> singletonVar v 1 - (isConstant -> Just constant) -> do - return $ Just $ Sparse [] mempty constant - (isAddVector -> Just (e1, e2)) -> do - l1 <- go e1 - l2 <- go e2 - return $ Applicative.liftA2 (\x y -> addExprs 1 x 1 y) l1 l2 - (isSubVector -> Just (e1, e2)) -> do - l1 <- go e1 - l2 <- go e2 - return $ Applicative.liftA2 (\x y -> addExprs 1 x (-1) y) l1 l2 - _ -> - return Nothing - - singletonVar :: Lv -> Coefficient -> m (SparseLinearExpr MixedVariable) - singletonVar level coef = do - var <- lookupLvInBoundCtx currentPass level variables - let constant = Vector.replicate (product dimensions) 0 - return $ Sparse dimensions (Map.singleton var coef) constant - - isAddVector :: WHNFValue Builtin -> Maybe (WHNFValue Builtin, WHNFValue Builtin) - isAddVector = \case - VFreeVar ident [_, _, _, _, _, e1, e2] - | ident == identifierOf StdAddVector -> Just (argExpr e1, argExpr e2) - _ -> Nothing - - isSubVector :: WHNFValue Builtin -> Maybe (WHNFValue Builtin, WHNFValue Builtin) - isSubVector = \case - VFreeVar ident [_, _, _, _, _, e1, e2] - | ident == identifierOf StdSubVector -> Just (argExpr e1, argExpr e2) - _ -> Nothing - - isConstant :: WHNFValue Builtin -> Maybe Constant - isConstant = \case - VVecLiteral xs -> mconcat <$> traverse (isConstant . argExpr) xs - VRatLiteral r -> Just $ Vector.singleton (fromRational r) - _ -> Nothing - --------------------------------------------------------------------------------- --- Variable reduction - -reduceRemainingVariables :: - (MonadSMT m) => - MixedVariables -> - UnreducedVariableSolutions -> - BooleanExpr UnreducedAssertion -> - m (MaybeTrivial (MixedVariables, BooleanExpr SolvableAssertion, VariableNormalisationSteps)) -reduceRemainingVariables variables userVariableSolutions assertions = - logCompilerPass MidDetail "reduction of remaining unreduced user variables and assertions" $ do - -- So this is a little complex. We want to substitute all the reduced variables - -- through the assertions in one fell-swoop. However, to do so efficiently we need - -- to first substitute them through the vector variable solutions, otherwise we end up - -- normalising the solutions over and over again during substitution. - let solvedUserVariables = Set.fromList (fmap fst userVariableSolutions) - - -- First reduce the variables - (reducedVariables, reconstructionSteps, partialReducedVarEnv, solvedUserVariableIndices) <- - reduceVariables variables solvedUserVariables - - -- Subsitute through the solutions - reducedVarEnv <- substituteReducedVariablesThroughSolutions partialReducedVarEnv userVariableSolutions solvedUserVariableIndices - - -- Then reduce the assertions - logDebug MidDetail "Substituting reduced variables through assertions..." - let reduceAssertion = compileReducedAssertion variables reducedVariables reducedVarEnv - compiledAssertions <- traverse reduceAssertion assertions - - case eliminateTrivialAtoms compiledAssertions of - Trivial b -> return $ Trivial b - NonTrivial finalAssertions -> do - let finalExpr = concatBooleanExpr finalAssertions - logDebug MaxDetail $ line <> "Reduced assertions:" - logDebug MaxDetail $ indent 2 $ pretty finalExpr - return $ NonTrivial (reducedVariables, finalExpr, reverse reconstructionSteps) - -reduceVariables :: - (MonadCompile m) => - MixedVariables -> - Set UserVariable -> - m (MixedVariables, VariableNormalisationSteps, WHNFEnv Builtin, Map UserVariable Ix) -reduceVariables variables solvedUserVariables = do - logDebug MidDetail $ "Reducing unsolved variables..." <> line - (userVarLv, reducedUserVariables, userVarReconstructionSteps, reducedUserVarEnv, solvedUserVariableIndices) <- - foldrM (possiblyReduceVariable solvedUserVariables) (0, mempty, mempty, mempty, mempty) (userVariableCtx variables) - - (_, reducedNetworkVariables, allReconstructionSteps, reducedVarEnv, _) <- - foldrM (possiblyReduceVariable mempty) (userVarLv, [], userVarReconstructionSteps, reducedUserVarEnv, mempty) (networkVariableCtx variables) - - let finalSolvedUserVariableIndices = fmap (dbLevelToIndex (Lv $ length reducedVarEnv)) solvedUserVariableIndices - let reducedVariables = MixedVariables reducedUserVariables reducedNetworkVariables - return (reducedVariables, allReconstructionSteps, reducedVarEnv, finalSolvedUserVariableIndices) - where - possiblyReduceVariable :: - (MonadCompile m, Variable variable) => - Set variable -> - variable -> - (Lv, GenericBoundCtx variable, VariableNormalisationSteps, WHNFEnv Builtin, Map variable Lv) -> - m (Lv, GenericBoundCtx variable, VariableNormalisationSteps, WHNFEnv Builtin, Map variable Lv) - possiblyReduceVariable solvedVariables var (currentLv, reducedVariables, steps, env, solvedIndices) - | var `Set.member` solvedVariables = do - logDebug MaxDetail $ - "Variable" - <+> quotePretty var - <+> "not reduced as previously solved" - <> line - let newEnv = extendEnvWithBound (mkDefaultBinder varName ()) env - let newSolvedIndices = Map.insert var (Lv $ length env) solvedIndices - return (currentLv, reducedVariables, steps, newEnv, newSolvedIndices) - | isRationalVariable var = do - logDebug MaxDetail $ "Variable" <+> quotePretty var <+> "already fully reduced" <> line - let newNormVariables = var : reducedVariables - let newEnv = extendEnvWithBound (mkDefaultBinder varName ()) env - return (currentLv + 1, newNormVariables, steps, newEnv, solvedIndices) - | otherwise = do - let (newVars, newExpr) = reduceVariable currentLv var - logDebug MaxDetail $ "Variable" <+> quotePretty var <+> "reduced to" <> line <> indent 2 (pretty newVars) <> line - let newNormVariables = newVars <> reducedVariables - let newEnv = extendEnvWithDefined newExpr (mkDefaultBinder varName ()) env - return (currentLv + Lv (length newVars), newNormVariables, Reduce (toMixedVariable var) : steps, newEnv, solvedIndices) - where - varName = layoutAsText $ pretty var - -substituteReducedVariablesThroughSolutions :: + ---------------- + -- Base cases -- + ---------------- + VRatLiteral l -> return $ constantExpr l + VBoundVar lv [] -> singletonVarExpr 0 <$> getRationalVariable lv + --------------------- + -- Inductive cases -- + --------------------- + VNeg NegRat v -> scaleExpr (-1) <$> go v + VAdd AddRat e1 e2 -> addExprs 1 1 <$> go e1 <*> go e2 + VSub SubRat e1 e2 -> addExprs 1 (-1) <$> go e1 <*> go e2 + VMul MulRat e1 e2 -> do + e1' <- go e1 + e2' <- go e2 + case (isConstant e1', isConstant e2') of + (Just c1, _) -> return $ scaleExpr c1 e2' + (_, Just c2) -> return $ scaleExpr c2 e1' + _ -> throwError catchableUnsupportedNonLinearConstraint + VDiv DivRat e1 e2 -> do + e1' <- go e1 + e2' <- go e2 + case isConstant e2' of + (Just c2) -> return $ scaleExpr (1 / c2) e1' + _ -> throwError catchableUnsupportedNonLinearConstraint + ----------------- + -- Error cases -- + ----------------- + ex -> unexpectedExprError "compile linear rational expression" $ prettyVerbose ex + +compileTensorAssertion :: + (MonadQueryStructure m, MonadWriter [WHNFValue QueryBuiltin] m) => + WHNFSpine QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + m (MaybeTrivial Partitions) +compileTensorAssertion spine x y = do + x' <- compileTensorLinearExpr x + y' <- compileTensorLinearExpr y + let maybeAssertion = liftA2 tensorEqToAssertion x' y' + case maybeAssertion of + Just assertion -> return $ mkTrivialPartition assertion + Nothing -> compileBoolExpr =<< appStdlibDef StdEqualsVector spine + +compileTensorLinearExpr :: forall m. - (MonadSMT m) => - WHNFEnv Builtin -> - UnreducedVariableSolutions -> - Map UserVariable Ix -> - m (WHNFEnv Builtin) -substituteReducedVariablesThroughSolutions partialEnv solutions solvedVariablePositions = do - logDebug MidDetail "Substituting reduced variables through variable solutions..." - foldrM f partialEnv solutions + (MonadQueryStructure m) => + WHNFValue QueryBuiltin -> + m (Maybe (LinearExpr TensorVariable RationalTensor)) +compileTensorLinearExpr = go where - f :: (UserVariable, WHNFValue Builtin) -> WHNFEnv Builtin -> m (WHNFEnv Builtin) - f (var, solution) env = do - normalisedSolution <- renormalise env solution - let errorMsg = developerError $ "Environment index missing for solved variable" <+> quotePretty var - let index = unIx $ fromMaybe errorMsg $ Map.lookup var solvedVariablePositions - let newEntry = mkDefaultEnvEntry (layoutAsText $ pretty var) (Defined normalisedSolution) - let newEnv = take index env <> [newEntry] <> drop (index + 1) env - return newEnv - --------------------------------------------------------------------------------- --- Solving of unreduced assertions - -solveForReducedUserVariables :: - (MonadSMT m) => - MixedVariables -> - ConjunctAll SolvableAssertion -> - m ([Assertion NetworkVariable], VariableNormalisationSteps) -solveForReducedUserVariables variables assertions = - logCompilerPass MidDetail "elimination of user variables" $ do - ((ident, _), _) <- ask - - let userVars = fmap UserVar (userVariableCtx variables) - let userVariablesSet = Set.fromList userVars - - -- First remove those assertions that don't have any user variables in them. - let (withUserVars, withoutUserVars) = - partition (`referencesVariables` userVariablesSet) (conjunctsToList assertions) - - -- Then split out the equalities from the inequalities. - let (equalitiesWithUserVars, inequalitiesWithUserVars) = - partition isEquality withUserVars - - -- Try to solve for user variables using Gaussian elimination. - (gaussianSolutions, unusedEqualityExprs, _usedEqualityIDs) <- - gaussianElimination userVars (map assertionExpr equalitiesWithUserVars) - let gaussianReconstructionSteps = fmap mkGaussianReconstructionStep gaussianSolutions - let equalitiesNewlyWithoutUserVars = fmap (Assertion Equal) unusedEqualityExprs - - -- Eliminate the solved user variables in the inequalities - let reducedInequalities = - flip fmap inequalitiesWithUserVars $ \assertion -> - foldr (flip $ uncurry . substitute) assertion gaussianSolutions - - -- Calculate the set of unsolved user variables - let varsSolvedByGaussianElim = Set.fromList (fmap fst gaussianSolutions) - let varsUnsolvedByGaussianElim = Set.difference userVariablesSet varsSolvedByGaussianElim - - (inequalitiesNewlyWithoutUserVars, fourierMotzkinSteps) <- - if null varsUnsolvedByGaussianElim - then return (reducedInequalities, mempty) - else do - logWarning $ ResortingtoFMElimination (nameOf ident) varsUnsolvedByGaussianElim - - -- Eliminate the remaining unsolved user vars using Fourier-Motzkin elimination - (fourierMotzkinSolutions, fmElimOutputInequalities) <- - fourierMotzkinElimination varsUnsolvedByGaussianElim reducedInequalities - let eliminationSteps = fmap (uncurry EliminateViaFourierMotzkin) fourierMotzkinSolutions - return (fmElimOutputInequalities, eliminationSteps) - - -- Calculate the final set of (user-variable free) assertions - let allAssertions = withoutUserVars <> equalitiesNewlyWithoutUserVars <> inequalitiesNewlyWithoutUserVars - let reconstructionSteps = gaussianReconstructionSteps <> fourierMotzkinSteps - - let uneliminatedVarError v = - developerError $ "User variable" <+> quotePretty v <+> "not successfully eliminated in property" <+> quotePretty ident - let toNetworkVar v = fromMaybe (uneliminatedVarError v) (getNetworkVariable v) - let networkVarAssertions = fmap (mapAssertionVariables toNetworkVar) allAssertions - - -- Eliminate network variables - return (networkVarAssertions, reconstructionSteps) - -mkGaussianReconstructionStep :: (MixedVariable, SparseLinearExpr MixedVariable) -> VariableNormalisationStep -mkGaussianReconstructionStep (v, e) = - EliminateViaGaussian v (GaussianVariableSolution $ rearrangeExprToSolveFor v e) - --------------------------------------------------------------------------------- --- Compilation of fully reduced assertions - -compileReducedAssertion :: - (MonadSMT m) => - MixedVariables -> - MixedVariables -> - WHNFEnv Builtin -> - UnreducedAssertion -> - m (MaybeTrivial (BooleanExpr SolvableAssertion)) -compileReducedAssertion _originalVariables variables variableSubstEnv assertion = do - -- First normalise the expression under the new environment of reduced variables - normExpr <- renormalise variableSubstEnv assertion - - -- Then extract the relation and arguments - splitAssertions <- splitUpAssertions False normExpr - -- Then reduce the assertions - traverse (traverse reduceAssertion) splitAssertions + go :: WHNFValue QueryBuiltin -> m (Maybe (LinearExpr TensorVariable RationalTensor)) + go e = case e of + --------------------- + -- Inductive cases -- + --------------------- + VVectorAdd e1 e2 -> liftA2 (addExprs 1 1) <$> go e1 <*> go e2 + VVectorSub e1 e2 -> liftA2 (addExprs 1 (-1)) <$> go e1 <*> go e2 + ---------------- + -- Base cases -- + ---------------- + VVecLiteral {} -> do + return (constantExpr <$> getRationalTensor e) + VBoundVar lv [] -> do + var <- getTensorVariable lv + return $ Just $ singletonVarExpr (zeroTensor $ tensorVariableDims var) var + _ -> return Nothing + +getRationalTensor :: WHNFValue QueryBuiltin -> Maybe RationalTensor +getRationalTensor expr = uncurry RationalTensor <$> go expr where - variableCtx :: MixedVariableCtx - variableCtx = mixedVariableCtx variables - - splitUpAssertions :: - (MonadSMT m) => - Bool -> - WHNFValue Builtin -> - m (MaybeTrivial (BooleanExpr (WHNFValue Builtin, Relation, WHNFValue Builtin))) - splitUpAssertions alreadyLiftedIfs expr = case expr of - VBoolLiteral b -> return $ Trivial b - VBuiltinFunction And [e1, e2] -> do - ass1 <- splitUpAssertions alreadyLiftedIfs (argExpr e1) - ass2 <- splitUpAssertions alreadyLiftedIfs (argExpr e2) - return $ andTrivial Conjunct ass1 ass2 - VBuiltinFunction Or [e1, e2] -> do - ass1 <- splitUpAssertions alreadyLiftedIfs (argExpr e1) - ass2 <- splitUpAssertions alreadyLiftedIfs (argExpr e2) - return $ orTrivial Disjunct ass1 ass2 - VBuiltinFunction Not [e] -> case eliminateNot (argExpr e) of - -- This should always work at this stage. - Nothing -> compilerDeveloperError $ "Cannot eliminate 'not' over" <+> prettyVerbose e - Just result -> splitUpAssertions alreadyLiftedIfs result - VBuiltinFunction If [_, c, x, y] -> do - -- As the expression is of type `Bool` we can immediately unfold the `if`. - let unfoldedExpr = unfoldIf c (argExpr x) (argExpr y) - splitUpAssertions alreadyLiftedIfs unfoldedExpr - VBuiltinFunction (Equals _ op) [e1, e2] - | alreadyLiftedIfs -> return $ NonTrivial $ Query $ eqToRelation (argExpr e1) op (argExpr e2) - | otherwise -> liftIfs expr - VBuiltinFunction (Order _ op) [e1, e2] - | alreadyLiftedIfs -> return $ NonTrivial $ Query $ ordToRelation (argExpr e1) op (argExpr e2) - | otherwise -> liftIfs expr - _ -> - unexpectedExprError "compiling reduced assertion" (prettyVerbose expr) - - liftIfs :: - (MonadSMT m) => - WHNFValue Builtin -> - m (MaybeTrivial (BooleanExpr (WHNFValue Builtin, Relation, WHNFValue Builtin))) - liftIfs expr = do - maybeExprWithoutIf <- eliminateIfs expr - case maybeExprWithoutIf of - Nothing -> splitUpAssertions True expr - Just Nothing -> compilerDeveloperError $ "Cannot lift 'if' over" <+> prettyVerbose expr - Just (Just exprWithoutIf) -> do - let env = variableCtxToEnv variableCtx - normExprWithoutIf <- renormalise env exprWithoutIf - splitUpAssertions True normExprWithoutIf - - reduceAssertion :: - (MonadSMT m) => - (WHNFValue Builtin, Relation, WHNFValue Builtin) -> - m SolvableAssertion - reduceAssertion (lhs, rel, rhs) = do - lhsLinExpr <- compileReducedLinearExpr variableCtx lhs - rhsLinExpr <- compileReducedLinearExpr variableCtx rhs - -- And construct the reduced assertion - return $ constructReducedAssertion (lhsLinExpr, rel, rhsLinExpr) + go :: WHNFValue QueryBuiltin -> Maybe (TensorDimensions, Vector Rational) + go = \case + VRatLiteral r -> Just ([], Vector.singleton (fromRational r)) + VVecLiteral xs -> do + r <- traverse (go . argExpr) xs + let (dims, rs) = unzip r + case dims of + [] -> Nothing + (ds : _) -> Just (length xs : ds, mconcat rs) + _ -> Nothing -compileReducedLinearExpr :: +-------------------------------------------------------------------------------- +-- Infinite quantifier elimination + +compileExists :: + (MonadQueryStructure m) => + WHNFBinder QueryBuiltin -> + WHNFBoundEnv QueryBuiltin -> + Expr Ix QueryBuiltin -> + m (MaybeTrivial Partitions) +compileExists binder env body = do + let varName = getBinderName binder + let subpassDoc = "compilation of quantified variable" <+> quotePretty varName + logCompilerPass MidDetail subpassDoc $ do + -- Create the user variable + userVar <- createUserVar binder + + -- Update the global context + globalCtx <- get + let (userVarExpr, newGlobalCtx) = addUserVarToGlobalContext userVar globalCtx + put newGlobalCtx + + -- Normalise the expression + let newEnv = extendEnvWithDefined userVarExpr binder env + normExpr <- eval newEnv body + + -- Recursively compile the expression. + (partitions, networkInputEqualities) <- runWriterT (compileBoolExpr normExpr) + + -- Prepend network equalities to the tree (prepending is important for + -- performance as the search for constraints will find them first.) + networkEqPartitions <- networkEqualitiesToPartition networkInputEqualities + let finalPartitions = andTrivial andPartitions partitions networkEqPartitions + logDebug MaxDetail $ pretty finalPartitions + + -- Solve for the user variable. + eliminateExists finalPartitions userVar + +createUserVar :: + (MonadQueryStructure m) => + WHNFBinder QueryBuiltin -> + m OriginalUserVariable +createUserVar binder = do + let varName = getBinderName binder + checkUserVariableNameIsUnique varName + varDimensions <- checkUserVariableType binder + return $ + OriginalUserVariable + { userTensorVarName = varName, + userTensorVarDimensions = varDimensions + } + +checkUserVariableNameIsUnique :: + (MonadQueryStructure m) => + Name -> + m () +checkUserVariableNameIsUnique varName = do + localCtx <- getGlobalBoundCtx + let isDuplicateName = any (\v -> getBinderName v == varName) localCtx + when isDuplicateName $ do + PropertyMetaData {..} <- ask + throwError $ DuplicateQuantifierNames propertyProvenance varName + +checkUserVariableType :: forall m. - (MonadSMT m) => - MixedVariableCtx -> - WHNFValue Builtin -> - m (SparseLinearExpr MixedVariable) -compileReducedLinearExpr variables expr = do - lnfExpr <- convertToLNF expr - go lnfExpr + (MonadQueryStructure m) => + WHNFBinder QueryBuiltin -> + m TensorDimensions +checkUserVariableType binder = go (typeOf binder) where - go :: WHNFValue Builtin -> m (SparseLinearExpr MixedVariable) - go e = case e of - VBoundVar v [] -> - singletonVar v 1 - VBuiltinFunction (Neg NegRat) [RelevantExplicitArg _ (VBoundVar v [])] -> - singletonVar v (-1) - VRatLiteral l -> do - return $ Sparse mempty mempty (Vector.singleton (fromRational l)) - VBuiltinFunction (Add AddRat) [e1, e2] -> do - l1 <- go (argExpr e1) - l2 <- go (argExpr e2) - return $ addExprs 1 l1 1 l2 - VBuiltinFunction (Mul MulRat) [e1, e2] -> - case (argExpr e1, argExpr e2) of - (VRatLiteral l, VBoundVar v []) -> singletonVar v (fromRational l) - (VBoundVar v [], VRatLiteral l) -> singletonVar v (fromRational l) - _ -> throwError catchableUnsupportedNonLinearConstraint - VBuiltinFunction (Div DivRat) [e1, e2] -> - case (argExpr e1, argExpr e2) of - (VBoundVar v [], VRatLiteral l) -> - singletonVar v (fromRational (1 / l)) - _ -> throwError catchableUnsupportedNonLinearConstraint - ex -> unexpectedExprError currentPass $ prettyVerbose ex - - singletonVar :: Lv -> Coefficient -> m (SparseLinearExpr MixedVariable) - singletonVar level coef = do - var <- lookupLvInBoundCtx currentPass level variables - return (Sparse [] (Map.singleton var coef) (Vector.singleton 0)) + go :: WHNFType QueryBuiltin -> m TensorDimensions + go = \case + VRatType -> return [] + VVectorType tElem (VNatLiteral d) -> do + ds <- go tElem + return $ d : ds + tElem -> do + PropertyMetaData {..} <- ask + let p = provenanceOf binder + let baseName = getBinderName binder + let declIdent = fst propertyProvenance + throwError $ UnsupportedVariableType (queryFormatID queryFormat) declIdent p baseName tElem (typeOf binder) [BuiltinType Rat] + +networkEqualitiesToPartition :: (MonadQueryStructure m) => [WHNFValue Builtin] -> m (MaybeTrivial Partitions) +networkEqualitiesToPartition networkEqualities = do + (partitions, newNetworkEqualities) <- runWriterT (compileBoolExpr (foldr VAnd (VBoolLiteral True) networkEqualities)) + unless (null newNetworkEqualities) $ + compilerDeveloperError "New network equalities generated when compiling network equalities." + return partitions + +-- (mkSinglePartition (mempty, conjunct equalities)) +-------------------------------------------------------------------------------- +-- Vector operations preservation --- | Converts the provided expression to linear normal form, --- i.e. consisting of only additions and multiplications by constants. --- e.g. x + 3 * (x + y) ====> x + 3 * x + 3 * y -convertToLNF :: (MonadCompile m) => WHNFValue Builtin -> m (WHNFValue Builtin) -convertToLNF = lnf +-- | Constructs a temporary error with no real fields. This should be recaught +-- and populated higher up the query compilation process. +catchableUnsupportedAlternatingQuantifiersError :: CompileError +catchableUnsupportedAlternatingQuantifiersError = + UnsupportedAlternatingQuantifiers x x x where - lnf :: (MonadCompile m) => WHNFValue Builtin -> m (WHNFValue Builtin) - lnf expr = case expr of - VUniverse {} -> unexpectedTypeInExprError currentPass "Universe" - VPi {} -> unexpectedTypeInExprError currentPass "Pi" - VMeta {} -> resolutionError currentPass "Meta" - VLam {} -> caseError currentPass "Lam" ["QuantifierExpr"] - VFreeVar i _ -> normalisationError currentPass ("FreeVar" <+> pretty i) - VBuiltinFunction fun args -> do - args' <- traverse (lnf . argExpr) args - case (fun, args') of - (Neg dom, [e1]) -> return $ argExpr $ lowerNeg dom e1 - (Sub dom, [e1, e2]) -> return $ normSub dom e1 e2 - (Mul dom, [e1, e2]) -> return $ normMul dom e1 e2 - (Div dom, [e1, e2]) -> return $ normDiv dom e1 e2 - _ -> return $ VBuiltinFunction fun (Arg mempty Explicit Relevant <$> args') - VBuiltin {} -> return expr - VBoundVar {} -> return expr - - normMul :: MulDomain -> WHNFValue Builtin -> WHNFValue Builtin -> WHNFValue Builtin - normMul dom e1 e2 = case (e1, e2) of - (_, VBuiltinFunction (Add addDom) [v1, v2]) -> do - let r1 = normMul dom e1 (argExpr v1) - let r2 = normMul dom e1 (argExpr v2) - VBuiltinFunction (Add addDom) (Arg mempty Explicit Relevant <$> [r1, r2]) - (VBuiltinFunction (Add addDom) [v1, v2], _) -> do - let r1 = normMul dom (argExpr v1) e2 - let r2 = normMul dom (argExpr v2) e2 - VBuiltinFunction (Add addDom) (Arg mempty Explicit Relevant <$> [r1, r2]) - (x1, x2) -> case evalMul dom [x1, x2] of - Nothing -> VBuiltinFunction (Mul dom) (Arg mempty Explicit Relevant <$> [e1, e2]) - Just r -> r - - normSub :: SubDomain -> WHNFValue Builtin -> WHNFValue Builtin -> WHNFValue Builtin - normSub dom e1 e2 = do - let negDom = subToNegDomain dom - let addDom = subToAddDomain dom - VBuiltinFunction (Add addDom) [Arg mempty Explicit Relevant e1, lowerNeg negDom e2] - - normDiv :: DivDomain -> WHNFValue Builtin -> WHNFValue Builtin -> WHNFValue Builtin - normDiv dom e1 e2 = case (e1, e2) of - (_, VRatLiteral l) -> do - let mulDom = divToMulDomain dom - normMul mulDom e1 (VRatLiteral (1 / l)) - _ -> do - VBuiltinFunction (Div dom) (Arg mempty Explicit Relevant <$> [e1, e2]) - - lowerNeg :: NegDomain -> WHNFValue Builtin -> WHNFArg Builtin - lowerNeg dom expr = Arg mempty Explicit Relevant $ case expr of - -- Base cases - VBuiltinFunction (Neg _) [e] -> argExpr e - VIntLiteral x -> VIntLiteral (-x) - VRatLiteral x -> VRatLiteral (-x) - VBoundVar _ [] -> do - let mulDom = negToMulDomain dom - let minus1 = Arg mempty Explicit Relevant $ case dom of - NegInt -> VIntLiteral (-1) - NegRat -> VRatLiteral (-1) - VBuiltinFunction (Mul mulDom) [minus1, Arg mempty Explicit Relevant expr] - - -- Inductive cases - VBuiltinFunction (Add addDom) [e1, e2] -> - VBuiltinFunction (Add addDom) [lowerNeg dom (argExpr e1), lowerNeg dom (argExpr e2)] - VBuiltinFunction (Mul mulDom) [e1, e2] -> - VBuiltinFunction (Mul mulDom) [lowerNeg dom (argExpr e1), e2] - -- Errors - e -> developerError ("Unable to lower 'neg' through" <+> pretty (show e)) - -currentPass :: Doc a -currentPass = "linear satisfaction problem" + x = developerError "Evaluating temporary quantifier error" -- | Constructs a temporary error with no real fields. This should be recaught -- and populated higher up the query compilation process. diff --git a/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/Core.hs b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/Core.hs new file mode 100644 index 000000000..b0ae499e0 --- /dev/null +++ b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/Core.hs @@ -0,0 +1,720 @@ +module Vehicle.Backend.Queries.UserVariableElimination.Core where + +import Control.Monad.Reader (MonadReader (..), asks) +import Control.Monad.State (MonadState (..), gets) +import Data.Aeson (FromJSON, ToJSON) +import Data.Bifunctor (Bifunctor (..)) +import Data.HashMap.Strict (HashMap) +import Data.HashMap.Strict qualified as HashMap (insert, lookup) +import Data.LinkedHashMap (LinkedHashMap) +import Data.LinkedHashMap qualified as LinkedHashMap +import Data.List.NonEmpty qualified as NonEmpty +import Data.Map (Map) +import Data.Map qualified as Map +import Data.Set (Set) +import Data.Set qualified as Set +import Data.Vector qualified as Vector +import GHC.Generics +import Vehicle.Compile.Context.Free +import Vehicle.Compile.Error +import Vehicle.Compile.ExpandResources.Core +import Vehicle.Compile.Normalise.NBE (normaliseApp) +import Vehicle.Compile.Prelude +import Vehicle.Compile.Resource (NetworkType (..), dimensions) +import Vehicle.Data.BooleanExpr +import Vehicle.Data.BuiltinInterface.Expr +import Vehicle.Data.BuiltinInterface.Value +import Vehicle.Data.Hashing () +import Vehicle.Data.LinearExpr +import Vehicle.Data.NormalisedExpr +import Vehicle.Libraries.StandardLibrary.Definitions +import Vehicle.Syntax.Builtin +import Vehicle.Verify.Core +import Vehicle.Verify.QueryFormat.Interface +import Vehicle.Verify.Variable + +-------------------------------------------------------------------------------- +-- Builtins + +type QueryBuiltin = Builtin + +-------------------------------------------------------------------------------- +-- Network applications + +-- | A single application of a neural network to a set of arguments. +type NetworkApplication = (Name, WHNFSpine QueryBuiltin) + +-- | Bookkeeping information associated with an application that describes +-- the variables and corresponding expressions that replace a given +-- NetworkApplication. +data NetworkApplicationReplacement = NetworkApplicationReplacement + { networkApp :: NetworkApplication, + networkInfo :: NetworkContextInfo, + inputVar :: OriginalNetworkVariable, + inputVarExpr :: WHNFValue QueryBuiltin, + inputRationalVars :: [NetworkRationalVariable], + outputVar :: OriginalNetworkVariable, + outputVarExpr :: WHNFValue QueryBuiltin, + outputRationalVars :: [NetworkRationalVariable] + } + +-------------------------------------------------------------------------------- +-- Reader state + +data PropertyMetaData = PropertyMetaData + { queryFormat :: QueryFormat, + networkCtx :: NetworkContext, + unalteredFreeContext :: FreeCtx QueryBuiltin, + propertyProvenance :: DeclProvenance, + propertyAddress :: PropertyAddress + } + +-------------------------------------------------------------------------------- +-- Global state + +data GlobalCtx = GlobalCtx + { globalBoundVarCtx :: LinkedHashMap Lv Variable, + userVariableReductions :: HashMap OriginalUserVariable ([UserRationalVariable], WHNFValue QueryBuiltin), + networkVariableReductions :: HashMap OriginalNetworkVariable ([NetworkRationalVariable], WHNFValue QueryBuiltin), + networkApplications :: LinkedHashMap NetworkApplication NetworkApplicationReplacement + } + +emptyGlobalCtx :: GlobalCtx +emptyGlobalCtx = + GlobalCtx + { globalBoundVarCtx = LinkedHashMap.empty, + userVariableReductions = mempty, + networkVariableReductions = mempty, + networkApplications = LinkedHashMap.empty + } + +addVectorVarToBoundVarCtx :: + (variable -> TensorVariable) -> + (ReducedVariable variable -> RationalVariable) -> + (Lv, variable) -> + [(Lv, ReducedVariable variable)] -> + LinkedHashMap Lv Variable +addVectorVarToBoundVarCtx fromVar1 fromVar2 tensorVar elemVars = do + let tensorVar' = second (TensorVar . fromVar1) tensorVar + let elemVars' = fmap (second (RationalVar . fromVar2)) elemVars + LinkedHashMap.union (LinkedHashMap.fromList elemVars') (LinkedHashMap.fromList [tensorVar']) + +addUserVarToGlobalContext :: + OriginalUserVariable -> + GlobalCtx -> + (WHNFValue QueryBuiltin, GlobalCtx) +addUserVarToGlobalContext userVar GlobalCtx {..} = do + -- Create the unreduced and reduced versions of the user variables. + let currentLevel = Lv $ length globalBoundVarCtx + let envEntry@(reducedUseVars, _) = reduceVariable userTensorVarDimensions (currentLevel + 1) userVar + let userVarExpr = VBoundVar currentLevel [] + let newGlobalCtx = + GlobalCtx + { globalBoundVarCtx = LinkedHashMap.union (addVectorVarToBoundVarCtx UserTensorVar UserRationalVar (currentLevel, userVar) reducedUseVars) globalBoundVarCtx, + userVariableReductions = HashMap.insert userVar (first (fmap snd) envEntry) userVariableReductions, + .. + } + (userVarExpr, newGlobalCtx) + +addNetworkApplicationToGlobalCtx :: + NetworkApplication -> + NetworkContextInfo -> + GlobalCtx -> + (NetworkApplicationReplacement, GlobalCtx) +addNetworkApplicationToGlobalCtx app@(networkName, _) networkInfo GlobalCtx {..} = do + let metaNetworkSoFar = LinkedHashMap.toList networkApplications + let applicationNumber = length $ filter (\((name, _), _) -> name == networkName) metaNetworkSoFar + + -- Create a single variable for the input of the network to + -- (avoiding prematurely normalising so that we can potentially solve + -- user tensor variables in terms of it). + let inputLv = Lv $ length globalBoundVarCtx + let inputVar = + OriginalNetworkVariable + { networkName = networkName, + application = applicationNumber, + networkTensorVarDimensions = dimensions (inputTensor (networkType networkInfo)), + inputOrOutput = Input, + startingIndex = sum (fmap (length . inputRationalVars . snd) metaNetworkSoFar) + } + let (reducedInputVars, reducedInputVarsExpr) = reduceVariable networkTensorVarDimensions (inputLv + 1) inputVar + let inputVarExpr = VBoundVar inputLv [] + + -- Create a tensor of variables for the output of the network. + let outputLv = inputLv + 1 + Lv (length reducedInputVars) + let outputVar = + OriginalNetworkVariable + { networkName = networkName, + application = applicationNumber, + networkTensorVarDimensions = dimensions (outputTensor (networkType networkInfo)), + inputOrOutput = Output, + startingIndex = sum (fmap (length . outputRationalVars . snd) metaNetworkSoFar) + } + let (reducedOutputVars, reducedOutputVarsExpr) = reduceVariable networkTensorVarDimensions (outputLv + 1) outputVar + let outputVarExpr = VBoundVar outputLv [] + + -- Create the context extension of the bound context. + let newGlobalBoundVarCtx = + LinkedHashMap.unions + [ addVectorVarToBoundVarCtx NetworkTensorVar NetworkRationalVar (outputLv, outputVar) reducedOutputVars, + addVectorVarToBoundVarCtx NetworkTensorVar NetworkRationalVar (inputLv, inputVar) reducedInputVars, + globalBoundVarCtx + ] + + -- Create the object to store information about the application + let appInfo = + NetworkApplicationReplacement + { networkApp = app, + networkInfo = networkInfo, + inputVar = inputVar, + inputVarExpr = inputVarExpr, + inputRationalVars = fmap snd reducedInputVars, + outputVar = outputVar, + outputVarExpr = outputVarExpr, + outputRationalVars = fmap snd reducedOutputVars + } + + let newNetworkVariableReductions = + HashMap.insert inputVar (fmap snd reducedInputVars, reducedInputVarsExpr) $ + HashMap.insert + outputVar + (fmap snd reducedOutputVars, reducedOutputVarsExpr) + networkVariableReductions + + let newGlobalCtx = + GlobalCtx + { globalBoundVarCtx = newGlobalBoundVarCtx, + networkVariableReductions = newNetworkVariableReductions, + networkApplications = LinkedHashMap.insert app appInfo networkApplications, + .. + } + + (appInfo, newGlobalCtx) + +-------------------------------------------------------------------------------- +-- Rational equalities + +newtype RationalEquality = RationalEquality + { rationalEqExpr :: LinearExpr RationalVariable Rational + } + deriving (Show, Eq, Ord, Generic) + +instance ToJSON RationalEquality + +instance FromJSON RationalEquality + +instance Pretty RationalEquality where + pretty e = pretty (rationalEqExpr e) <+> "== 0" + +-- | Checks whether an assertion is trivial or not. Returns `Nothing` if +-- non-trivial, and otherwise `Just b` where `b` is the value of the assertion +-- if it is trivial. +checkRationalEqualityTriviality :: RationalEquality -> Maybe Bool +checkRationalEqualityTriviality (RationalEquality e) = case isConstant e of + Nothing -> Nothing + Just c -> Just $ c == 0.0 + +-------------------------------------------------------------------------------- +-- Rational inequalities + +data RationalInequality = RationalInequality + { strictness :: Strictness, + rationalIneqExpr :: LinearExpr RationalVariable Rational + } + deriving (Show, Eq, Ord, Generic) + +instance ToJSON RationalInequality + +instance FromJSON RationalInequality + +instance Pretty RationalInequality where + pretty ineq = + pretty (rationalIneqExpr ineq) + <+> (if strictness ineq == Strict then "<" else "<=") + <+> "0.0" + +-- | Checks whether an assertion is trivial or not. Returns `Nothing` if +-- non-trivial, and otherwise `Just b` where `b` is the value of the assertion +-- if it is trivial. +checkRationalInequalityTriviality :: RationalInequality -> Maybe Bool +checkRationalInequalityTriviality (RationalInequality s e) = case isConstant e of + Nothing -> Nothing + Just c -> Just $ case s of + Strict -> c < 0.0 + NonStrict -> c <= 0.0 + +-------------------------------------------------------------------------------- +-- Tensor equalities + +newtype TensorEquality = TensorEquality + { tensorEqExpr :: LinearExpr TensorVariable RationalTensor + } + deriving (Show, Eq, Ord, Generic) + +instance Pretty TensorEquality where + pretty TensorEquality {..} = pretty tensorEqExpr <+> "== 0" + +instance ToJSON TensorEquality + +instance FromJSON TensorEquality + +-------------------------------------------------------------------------------- +-- Assertions + +data Assertion + = RationalEq RationalEquality + | RationalIneq RationalInequality + | TensorEq TensorEquality + deriving (Show, Eq, Generic) + +instance ToJSON Assertion + +instance FromJSON Assertion + +instance Pretty Assertion where + pretty = \case + RationalEq eq -> pretty eq + RationalIneq ineq -> pretty ineq + TensorEq eq -> pretty eq + +checkTriviality :: Assertion -> MaybeTrivial Assertion +checkTriviality ass = case ass of + RationalEq RationalEquality {..} -> case isConstant rationalEqExpr of + Nothing -> NonTrivial ass + Just d -> Trivial (d == 0) + RationalIneq RationalInequality {..} -> case isConstant rationalIneqExpr of + Nothing -> NonTrivial ass + Just d -> Trivial ((if strictness == Strict then (<) else (<=)) d 0) + TensorEq TensorEquality {..} -> case isConstant tensorEqExpr of + Nothing -> NonTrivial ass + Just d -> Trivial (isZero d) + +prettyAssertions :: [Assertion] -> Doc a +prettyAssertions assertions = + vsep (fmap pretty assertions) + +prettyInequalities :: [RationalInequality] -> Doc a +prettyInequalities assertions = + vsep (fmap pretty assertions) + +data Relation + = Equal + | LessThan + | LessThanOrEqual + deriving (Eq, Ord) + +assertionRel :: Assertion -> Relation +assertionRel = \case + RationalEq {} -> Equal + TensorEq {} -> Equal + RationalIneq ineq + | strictness ineq == Strict -> LessThan + | otherwise -> LessThanOrEqual + +eqToAssertion :: + LinearExpr RationalVariable Rational -> + LinearExpr RationalVariable Rational -> + Assertion +eqToAssertion e1 e2 = do + let e = addExprs 1 (-1) e1 e2 + RationalEq $ RationalEquality e + +ordToAssertion :: + OrderOp -> + LinearExpr RationalVariable Rational -> + LinearExpr RationalVariable Rational -> + Assertion +ordToAssertion op e1 e2 = + RationalIneq $ case op of + Lt -> RationalInequality Strict (addExprs 1 (-1) e1 e2) + Le -> RationalInequality NonStrict (addExprs 1 (-1) e1 e2) + Gt -> RationalInequality Strict (addExprs (-1) 1 e1 e2) + Ge -> RationalInequality NonStrict (addExprs (-1) 1 e1 e2) + +tensorEqToAssertion :: + LinearExpr TensorVariable RationalTensor -> + LinearExpr TensorVariable RationalTensor -> + Assertion +tensorEqToAssertion e1 e2 = do + let e = addExprs 1 (-1) e1 e2 + TensorEq $ TensorEquality e + +mapAssertionExprs :: + (LinearExpr TensorVariable RationalTensor -> LinearExpr TensorVariable RationalTensor) -> + (LinearExpr RationalVariable Rational -> LinearExpr RationalVariable Rational) -> + Assertion -> + MaybeTrivial Assertion +mapAssertionExprs ft fr ass = checkTriviality $ case ass of + TensorEq TensorEquality {..} -> TensorEq $ TensorEquality $ ft tensorEqExpr + RationalEq RationalEquality {..} -> RationalEq $ RationalEquality $ fr rationalEqExpr + RationalIneq RationalInequality {..} -> RationalIneq $ RationalInequality strictness (fr rationalIneqExpr) + +substituteTensorEq :: + (OriginalUserVariable, TensorEquality) -> + Map RationalVariable RationalEquality -> + Assertion -> + MaybeTrivial Assertion +substituteTensorEq (var, solution) ratSolutions = + mapAssertionExprs + (eliminateVar (UserTensorVar var) (tensorEqExpr solution)) + eliminateRatVars + where + -- Usually the expression being substituted into is much smaller than the number of tensor + -- variables so we traverse the expression instead of folding over the subsitutions + eliminateRatVars :: LinearExpr RationalVariable Rational -> LinearExpr RationalVariable Rational + eliminateRatVars expr = do + let varExprs = lookupVar <$> Map.toList (coefficients expr) + let constantExp = Sparse (mempty @(Map RationalVariable Coefficient)) (constantValue expr) + foldr (addExprs 1 1) constantExp varExprs + + lookupVar :: (RationalVariable, Coefficient) -> LinearExpr RationalVariable Rational + lookupVar (v, c) = do + let vc = Sparse (Map.singleton v c) 0 + case Map.lookup v ratSolutions of + Nothing -> vc + Just sol -> eliminateVar v (rationalEqExpr sol) vc + +substituteRationalEq :: UserRationalVariable -> RationalEquality -> Assertion -> MaybeTrivial Assertion +substituteRationalEq var solution = + mapAssertionExprs id (eliminateVar (UserRationalVar var) (rationalEqExpr solution)) + +-------------------------------------------------------------------------------- +-- Partitions + +type AssertionTree = BooleanExpr Assertion + +-- | One step in the process for transforming unreduced user variables into +-- reduced network input and output variables. +data UserVariableReconstructionStep + = SolveTensorEquality OriginalUserVariable TensorEquality + | SolveRationalEquality UserRationalVariable RationalEquality + | SolveRationalInequalities UserRationalVariable FourierMotzkinVariableSolution + | ReconstructTensor OriginalUserVariable [UserRationalVariable] + deriving (Eq, Ord, Show, Generic) + +instance ToJSON UserVariableReconstructionStep + +instance FromJSON UserVariableReconstructionStep + +instance Pretty UserVariableReconstructionStep where + pretty = \case + SolveTensorEquality v _s -> "SolveTensorEquality[" <+> pretty v <+> "]" -- "=" <+> pretty s <+> "]" + SolveRationalEquality v _s -> "SolveRationalEquality[" <+> pretty v <+> "]" -- "=" <+> pretty s <+> "]" + SolveRationalInequalities v _ -> "SolveRationalInequalities[" <+> pretty v <+> "]" + ReconstructTensor v _vs -> "ReconstructTensor[" <+> pretty v <+> "]" + +-- | The steps for transforming unreduced user variables into reduced network +-- input and output varibles. +-- These are used to recreate a satisfying assignment for the user variables +-- from the satisfying assignment for the network variables spat out by the +-- verifier. +-- +-- The steps are stored in the same order they occured during compilation. +type UserVariableReconstruction = [UserVariableReconstructionStep] + +type UserVarSolutions = UserVariableReconstruction + +addRationalEqualitySolution :: + UserRationalVariable -> + RationalEquality -> + UserVarSolutions -> + UserVarSolutions +addRationalEqualitySolution var eq solutions = + SolveRationalEquality var eq : solutions + +addRationalInequalitySolution :: + UserRationalVariable -> + FourierMotzkinVariableSolution -> + UserVarSolutions -> + UserVarSolutions +addRationalInequalitySolution var eq solutions = + SolveRationalInequalities var eq : solutions + +addTensorEqualitySolution :: + OriginalUserVariable -> + TensorEquality -> + UserVarSolutions -> + UserVarSolutions +addTensorEqualitySolution var eq solutions = + SolveTensorEquality var eq : solutions + +unionSolutions :: UserVarSolutions -> UserVarSolutions -> UserVarSolutions +unionSolutions = (<>) + +type Partition = (UserVarSolutions, AssertionTree) + +newtype Partitions = Partitions (Map UserVarSolutions AssertionTree) + +partitionsToDisjuncts :: Partitions -> DisjunctAll Partition +partitionsToDisjuncts (Partitions ps) = DisjunctAll $ NonEmpty.fromList $ Map.toList ps + +instance Pretty Partitions where + pretty = pretty . partitionsToDisjuncts + +andPartitions :: Partitions -> Partitions -> Partitions +andPartitions (Partitions xs) (Partitions ys) = do + let xs' = Map.toList xs + let ys' = Map.toList ys + let combine (s1, t1) (s2, t2) = (s1 <> s2, andBoolExpr t1 t2) + Partitions $ Map.fromList $ cartesianProduct combine xs' ys' + +orPartitions :: Partitions -> Partitions -> Partitions +orPartitions (Partitions p1) (Partitions p2) = + Partitions $ Map.unionWith orBoolExpr p1 p2 + +mkSinglePartition :: (UserVarSolutions, MaybeTrivial AssertionTree) -> MaybeTrivial Partitions +mkSinglePartition (solutions, maybeAssertion) = + fmap (Partitions . Map.singleton solutions) maybeAssertion + +mkTrivialPartition :: Assertion -> MaybeTrivial Partitions +mkTrivialPartition assertion = mkSinglePartition (mempty, NonTrivial $ Query assertion) + +-------------------------------------------------------------------------------- +-- Variable reconstruction + +-- | A FM solution for an normalised user variable is two lists of constraints. +-- The variable value must be greater than the first set of assertions, and less than +-- the second set of assertions. +data FourierMotzkinVariableSolution = FMSolution + { lowerBounds :: [RationalInequality], + upperBounds :: [RationalInequality] + } + deriving (Show, Eq, Ord, Generic) + +instance ToJSON FourierMotzkinVariableSolution + +instance FromJSON FourierMotzkinVariableSolution + +-------------------------------------------------------------------------------- +-- Monads + +type MonadPropertyStructure m = + ( MonadFreeContext QueryBuiltin m, + MonadReader PropertyMetaData m + ) + +type MonadQueryStructure m = + ( MonadPropertyStructure m, + MonadState GlobalCtx m + ) + +getGlobalBoundCtx :: (MonadQueryStructure m) => m (BoundCtx QueryBuiltin) +getGlobalBoundCtx = gets (variableCtxToBoundCtx . (fmap snd . LinkedHashMap.toList . globalBoundVarCtx)) + +lookupVarByLevel :: (MonadQueryStructure m) => Lv -> m Variable +lookupVarByLevel lv = do + GlobalCtx {..} <- get + case LinkedHashMap.lookup lv globalBoundVarCtx of + Nothing -> compilerDeveloperError "Cannout find variable var" + Just v -> return v + +getReducedVariableExprFor :: (MonadQueryStructure m) => Lv -> m (Maybe (WHNFValue QueryBuiltin)) +getReducedVariableExprFor lv = do + GlobalCtx {..} <- get + var <- lookupVarByLevel lv + case var of + TensorVar (UserTensorVar v) -> return (snd <$> HashMap.lookup v userVariableReductions) + TensorVar (NetworkTensorVar v) -> return (snd <$> HashMap.lookup v networkVariableReductions) + _ -> return Nothing + +getTensorVariable :: (MonadQueryStructure m) => Lv -> m TensorVariable +getTensorVariable lv = do + var <- lookupVarByLevel lv + case var of + TensorVar v -> return v + _ -> compilerDeveloperError "Expected tensor variable but found rational variable" + +getRationalVariable :: (MonadQueryStructure m) => Lv -> m RationalVariable +getRationalVariable lv = do + var <- lookupVarByLevel lv + case var of + RationalVar v -> return v + _ -> compilerDeveloperError "Expected rational variable but found tensor variable" + +getReducedUserVariablesFor :: (MonadQueryStructure m) => OriginalUserVariable -> m [UserRationalVariable] +getReducedUserVariablesFor var = do + GlobalCtx {..} <- get + case HashMap.lookup var userVariableReductions of + Just (vars, _) -> return vars + Nothing -> + compilerDeveloperError $ + "User variable" <+> pretty var <+> "has no reductions" + +getReducedNetworkVariablesFor :: (MonadCompile m) => GlobalCtx -> OriginalNetworkVariable -> m [NetworkRationalVariable] +getReducedNetworkVariablesFor GlobalCtx {..} var = do + case HashMap.lookup var networkVariableReductions of + Just (vars, _) -> return vars + Nothing -> + compilerDeveloperError $ + "Network variable" <+> pretty var <+> "has no reductions" + +getReducedVariablesFor :: (MonadCompile m) => GlobalCtx -> TensorVariable -> m [RationalVariable] +getReducedVariablesFor GlobalCtx {..} var = do + case var of + NetworkTensorVar v -> case HashMap.lookup v networkVariableReductions of + Just (vars, _) -> return $ fmap NetworkRationalVar vars + Nothing -> compilerDeveloperError $ "Network variable" <+> pretty var <+> "has no reductions" + UserTensorVar v -> case HashMap.lookup v userVariableReductions of + Just (vars, _) -> return $ fmap UserRationalVar vars + Nothing -> compilerDeveloperError $ "User variable" <+> pretty var <+> "has no reductions" + +appStdlibDef :: (MonadPropertyStructure m) => StdLibFunction -> WHNFSpine QueryBuiltin -> m (WHNFValue QueryBuiltin) +appStdlibDef fn spine = do + freeCtx <- asks unalteredFreeContext + (fnDef, _) <- lookupInFreeCtx "lookupStdlibDef" (identifierOf fn) freeCtx + case bodyOf fnDef of + Just fnBody -> normaliseApp fnBody spine + Nothing -> compilerDeveloperError $ "Unexpected found" <+> quotePretty fn <+> "to have no body" + +reduceTensorEquality :: + (MonadCompile m) => + GlobalCtx -> + TensorEquality -> + m [RationalEquality] +reduceTensorEquality globalCtx (TensorEquality (Sparse coeff constant)) = do + let constValues = Vector.toList $ tensorValues constant + let numRatEqs = product (tensorDims constant) + coeffList <- traverse (\(v, c) -> (,c) <$> getReducedVariablesFor globalCtx v) (Map.toList coeff) + let asserts = fmap (mkRatEquality coeffList constValues) [0 .. numRatEqs - 1] + return asserts + where + mkRatEquality :: + [([RationalVariable], Coefficient)] -> + [Rational] -> + Int -> + RationalEquality + mkRatEquality coeffs consts i = do + let expr = Sparse (Map.fromList (fmap (first (!! i)) coeffs)) (consts !! i) + RationalEquality expr + +-------------------------------------------------------------------------------- +-- Context operations + +variableCtxToBoundCtx :: (Pretty variable) => [variable] -> BoundCtx builtin +variableCtxToBoundCtx ctx = zipWith variableCtxToBoundCtxEntry [0 .. Ix (length ctx - 1)] ctx + where + variableCtxToBoundCtxEntry ix var = mkDefaultBinder (layoutAsText $ pretty var) (BoundVar mempty ix) + +-------------------------------------------------------------------------------- +-- Vector operation patterns + +pattern VInfiniteQuantifier :: + Quantifier -> + [WHNFArg QueryBuiltin] -> + WHNFBinder QueryBuiltin -> + WHNFBoundEnv QueryBuiltin -> + Expr Ix QueryBuiltin -> + WHNFValue QueryBuiltin +pattern VInfiniteQuantifier q args binder env body <- + VBuiltinFunction (Quantifier q) (reverse -> RelevantExplicitArg _ (VLam binder (WHNFBody env body)) : args) + where + VInfiniteQuantifier q args binder env body = + VBuiltinFunction (Quantifier q) (reverse (Arg mempty Explicit Relevant (VLam binder (WHNFBody env body)) : args)) + +pattern VForall :: + [WHNFArg QueryBuiltin] -> + WHNFBinder QueryBuiltin -> + WHNFBoundEnv QueryBuiltin -> + Expr Ix QueryBuiltin -> + WHNFValue QueryBuiltin +pattern VForall args binder env body = VInfiniteQuantifier Forall args binder env body + +pattern VExists :: + [WHNFArg QueryBuiltin] -> + WHNFBinder QueryBuiltin -> + WHNFBoundEnv QueryBuiltin -> + Expr Ix QueryBuiltin -> + WHNFValue QueryBuiltin +pattern VExists args binder env body = VInfiniteQuantifier Exists args binder env body + +pattern VVecEqSpine :: + WHNFArg QueryBuiltin -> + WHNFArg QueryBuiltin -> + WHNFArg QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFSpine QueryBuiltin +pattern VVecEqSpine t1 t2 dim sol x y <- [t1, t2, dim, argExpr -> sol, argExpr -> x, argExpr -> y] + where + VVecEqSpine t1 t2 dim sol x y = [t1, t2, dim, Arg mempty (Instance True) Relevant sol, Arg mempty Explicit Relevant x, Arg mempty Explicit Relevant y] + +pattern VVecOp2Spine :: + WHNFArg QueryBuiltin -> + WHNFArg QueryBuiltin -> + WHNFArg QueryBuiltin -> + WHNFArg QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFSpine QueryBuiltin +pattern VVecOp2Spine t1 t2 t3 dim sol x y <- [t1, t2, t3, dim, argExpr -> sol, argExpr -> x, argExpr -> y] + +pattern VVecEqArgs :: + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFSpine QueryBuiltin +pattern VVecEqArgs x y <- VVecEqSpine _ _ _ _ x y + +pattern VVectorEqualFull :: WHNFSpine QueryBuiltin -> WHNFValue QueryBuiltin +pattern VVectorEqualFull spine = VStandardLib StdEqualsVector spine + +pattern VVectorNotEqualFull :: WHNFSpine QueryBuiltin -> WHNFValue QueryBuiltin +pattern VVectorNotEqualFull spine = VStandardLib StdNotEqualsVector spine + +pattern VVectorEqual :: WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin +pattern VVectorEqual x y <- VVectorEqualFull (VVecEqArgs x y) + +pattern VVectorNotEqual :: WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin +pattern VVectorNotEqual x y <- VVectorNotEqualFull (VVecEqArgs x y) + +pattern VVectorAdd :: WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin +pattern VVectorAdd x y <- VStandardLib StdAddVector [_, _, _, _, _, argExpr -> x, argExpr -> y] + +pattern VVectorSub :: WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin +pattern VVectorSub x y <- VStandardLib StdSubVector [_, _, _, _, _, argExpr -> x, argExpr -> y] + +pattern VAt :: WHNFArg QueryBuiltin -> WHNFArg QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin +pattern VAt t n x y <- VBuiltinFunction At [t, n, argExpr -> x, argExpr -> y] + where + VAt t n x y = VBuiltinFunction At [t, n, Arg mempty Explicit Relevant x, Arg mempty Explicit Relevant y] + +mkVVectorEquality :: + TensorDimensions -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin -> + WHNFValue QueryBuiltin +mkVVectorEquality dimensions e1 e2 = do + mkVectorEquality (fmap VNatLiteral dimensions) (Arg mempty Explicit Relevant <$> [e1, e2]) + where + -- Would definitely be nicer to somehow reuse the type-class resolution machinery here, + -- but it seems incredibly complicated to setup... + mkVectorEquality :: [WHNFValue QueryBuiltin] -> WHNFSpine QueryBuiltin -> WHNFValue QueryBuiltin + mkVectorEquality dims spine = + let p = mempty + in case dims of + [] -> VBuiltinFunction (Equals EqRat Eq) spine + d : ds -> VFreeVar (identifierOf StdEqualsVector) (nonExplicitArgs <> spine) + where + tensorType = foldr (\dim t -> mkVVectorType t dim) VRatType ds + nonExplicitArgs = + [ Arg p (Implicit True) Relevant tensorType, + Arg p (Implicit True) Relevant tensorType, + Arg p (Implicit True) Irrelevant d, + Arg p (Instance True) Relevant (mkVectorEquality ds []) + ] + +negExpr :: Expr Ix QueryBuiltin -> Expr Ix QueryBuiltin +negExpr body = NotExpr mempty [Arg mempty Explicit Relevant body] + +-- | The set of vector operations that we sometimes want to avoid normalising +-- out in the property for efficiency reasons. +vectorOperations :: Set Identifier +vectorOperations = + Set.fromList $ + identifierOf + <$> [ StdAddVector, + StdSubVector, + StdEqualsVector, + StdNotEqualsVector + ] diff --git a/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/EliminateExists.hs b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/EliminateExists.hs new file mode 100644 index 000000000..7b035b355 --- /dev/null +++ b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/EliminateExists.hs @@ -0,0 +1,140 @@ +module Vehicle.Backend.Queries.UserVariableElimination.EliminateExists + ( eliminateExists, + ) +where + +import Control.Monad.Reader (MonadReader (..)) +import Control.Monad.State (MonadState (..)) +import Data.Foldable (foldlM) +import Data.Map qualified as Map +import Vehicle.Backend.Queries.ConstraintSearch +import Vehicle.Backend.Queries.UserVariableElimination.Core +import Vehicle.Backend.Queries.UserVariableElimination.FourierMotzkinElimination +import Vehicle.Compile.Error +import Vehicle.Compile.Prelude +import Vehicle.Data.BooleanExpr +import Vehicle.Data.LinearExpr (referencesVariable) +import Vehicle.Prelude.Warning (CompileWarning (..)) +import Vehicle.Verify.Variable + +-------------------------------------------------------------------------------- +-- Main function + +-- | Eliminates the provided user variable from the assertion tree. This may +-- require partially converting the expression to disjunctive normal form so it +-- returns a set of disjuncted updated assertion trees and variable solutions. +eliminateExists :: + (MonadQueryStructure m) => + MaybeTrivial Partitions -> + OriginalUserVariable -> + m (MaybeTrivial Partitions) +eliminateExists partitions userVariable = do + logCompilerPass MaxDetail ("solving for user variable" <+> quotePretty userVariable) $ + solveExists fromTensorAssertion solveTensorVariable partitions userVariable + +type MonadSolveExists m = MonadQueryStructure m + +type ConstraintSolver m variable equality = + variable -> UserVarSolutions -> ConstrainedAssertionTree equality -> m (MaybeTrivial Partitions) + +solveExists :: + (MonadSolveExists m, Pretty variable, Pretty equality) => + ConstraintSearchCriteria variable equality -> + ConstraintSolver m variable equality -> + MaybeTrivial Partitions -> + variable -> + m (MaybeTrivial Partitions) +solveExists searchCriteria solveVarConstraints partitions userVar = do + let solve (sol, tree) = do + logDebug MaxDetail ("Solving for" <+> pretty userVar <+> "in" <+> quotePretty tree) + constraints <- findVariableConstraints searchCriteria userVar tree + traverse (solveVarConstraints userVar sol) constraints + results <- traverse (traverse solve . partitionsToDisjuncts) partitions + let flattenedResults = + flattenTrivial $ fmap (fmap (foldr1 orPartitions) . eliminateTrivialDisjunctions . disjunctDisjuncts) results + logDebug MaxDetail ("Final queries" <+> quotePretty flattenedResults) + return flattenedResults + +-------------------------------------------------------------------------------- +-- Tensor equalities + +fromTensorAssertion :: OriginalUserVariable -> Assertion -> ConstrainedAssertionTree TensorEquality +fromTensorAssertion var = \case + TensorEq eq | tensorEqExpr eq `referencesVariable` UserTensorVar var -> Equality (eq, Trivial True) + assertion -> NoConstraints (Query assertion) + +solveTensorVariable :: + (MonadSolveExists m) => + OriginalUserVariable -> + UserVarSolutions -> + ConstrainedAssertionTree TensorEquality -> + m (MaybeTrivial Partitions) +solveTensorVariable userTensorVar solutions = \case + Equality (tensorEq, remainingTree) -> do + logDebug MaxDetail $ + "Solving tensor equality:" + <> line + <> indent 2 (pretty tensorEq) + <> line + <> "in context:" + <> line + <> indent 2 (pretty remainingTree) + + -- Generate accompanying rational solutions + globalCtx <- get + rationalEqualties <- reduceTensorEquality globalCtx tensorEq + userRationalVars <- getReducedUserVariablesFor userTensorVar + let solutionMap = Map.fromList $ zip (fmap UserRationalVar userRationalVars) rationalEqualties + -- Update tree + let updatedTree = fmap (fmap (substituteTensorEq (userTensorVar, tensorEq) solutionMap)) remainingTree + let updatedUserVarSolutions = SolveTensorEquality userTensorVar tensorEq : solutions + return $ mkSinglePartition (updatedUserVarSolutions, filterTrivialAtoms updatedTree) + NoConstraints tree -> do + logDebug MaxDetail "No constraints on original variable found" + userRationalVars <- getReducedUserVariablesFor userTensorVar + let initial = mkSinglePartition (solutions, NonTrivial tree) + foldlM (solveExists fromRationalAssertion solveRationalVariable) initial userRationalVars + Inequalities {} -> + compilerDeveloperError $ + "When trying to solve rational variable" + <+> quotePretty userTensorVar + <+> "found unexpected tensor inequalities." + +-------------------------------------------------------------------------------- +-- UserRationalVariables and equalities/constraints + +fromRationalAssertion :: UserRationalVariable -> Assertion -> ConstrainedAssertionTree RationalEquality +fromRationalAssertion var = \case + RationalEq eq | rationalEqExpr eq `referencesVariable` UserRationalVar var -> Equality (eq, Trivial True) + RationalIneq ineq | rationalIneqExpr ineq `referencesVariable` UserRationalVar var -> Inequalities (ConjunctAll [ineq], Trivial True) + assertion -> NoConstraints (Query assertion) + +solveRationalVariable :: + (MonadSolveExists m) => + UserRationalVariable -> + UserVarSolutions -> + ConstrainedAssertionTree RationalEquality -> + m (MaybeTrivial Partitions) +solveRationalVariable var solutions constraint = + mkSinglePartition <$> case constraint of + Equality (eq, remainingTree) -> do + let updatedTree = fmap (fmap (substituteRationalEq var eq)) remainingTree + let updatedUserVarSolutions = addRationalEqualitySolution var eq solutions + return (updatedUserVarSolutions, filterTrivialAtoms updatedTree) + Inequalities (ineqs, remainingTree) -> solveRationalInequalities var solutions (conjunctsToList ineqs) remainingTree + NoConstraints tree -> solveRationalInequalities var solutions [] (NonTrivial tree) + +solveRationalInequalities :: + (MonadSolveExists m) => + UserRationalVariable -> + UserVarSolutions -> + [RationalInequality] -> + MaybeTrivial AssertionTree -> + m (UserVarSolutions, MaybeTrivial AssertionTree) +solveRationalInequalities var solutions ineqs remainingTree = do + PropertyMetaData {..} <- ask + logWarning $ UnderSpecifiedProblemSpaceVar propertyAddress var + (solution, newInequalities) <- fourierMotzkinElimination var ineqs + let updatedTree = andTrivial andBoolExpr remainingTree (conjunct $ fmap RationalIneq newInequalities) + let updatedUserVarSolutions = SolveRationalInequalities var solution : solutions + return (updatedUserVarSolutions, updatedTree) diff --git a/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/EliminateNot.hs b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/EliminateNot.hs new file mode 100644 index 000000000..27486d1bb --- /dev/null +++ b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/EliminateNot.hs @@ -0,0 +1,67 @@ +module Vehicle.Backend.Queries.UserVariableElimination.EliminateNot + ( eliminateNot, + ) +where + +import Control.Monad.Writer +import Vehicle.Backend.Queries.UserVariableElimination.Core +import Vehicle.Backend.Queries.UserVariableElimination.Unblocking (tryUnblockBool) +import Vehicle.Compile.Error (compilerDeveloperError) +import Vehicle.Compile.Prelude +import Vehicle.Compile.Print (prettyVerbose) +import Vehicle.Data.BuiltinInterface.Value +import Vehicle.Data.NormalisedExpr +import Vehicle.Libraries.StandardLibrary.Definitions (StdLibFunction (StdNotBoolOp2)) + +-------------------------------------------------------------------------------- +-- Not elimination + +-- | Tries to push in a `Not` function as far as possible. Note that it will not +-- push it past a `Fold` application, and therefore these need to be tested for +-- and eliminated before applying this function. +eliminateNot :: + forall m. + (MonadQueryStructure m, MonadWriter [WHNFValue QueryBuiltin] m) => + WHNFValue QueryBuiltin -> + m (WHNFValue QueryBuiltin) +eliminateNot = go + where + go :: WHNFValue QueryBuiltin -> m (WHNFValue QueryBuiltin) + go = \case + ---------------- + -- Base cases -- + ---------------- + VNot x -> return x + VBoolLiteral b -> return $ VBoolLiteral (not b) + VOrder dom eq x y -> return $ VOrder dom (neg eq) x y + VEqual dom x y -> return $ VNotEqual dom x y + VNotEqual dom x y -> return $ VEqual dom x y + -- We can't actually lower the `not` through the body of the quantifier as + -- it is not yet unnormalised. However, it's fine to stop here as we'll + -- simply continue to normalise it once we re-encounter it again after + -- normalising the quantifier. + VForall args binder env body -> return $ VExists args binder env (negExpr body) + VExists args binder env body -> return $ VForall args binder env (negExpr body) + -- It's not enough simply to negate the free variable, we also need + -- to negate the instance argument solution for the function + -- which is a function accepting two arguments and returning a bool. + VVectorEqualFull spine -> VVectorNotEqualFull <$> negVectorEqSpine spine + VVectorNotEqualFull spine -> VVectorEqualFull <$> negVectorEqSpine spine + --------------------- + -- Inductive cases -- + --------------------- + VOr x y -> VAnd <$> go x <*> go y + VAnd x y -> VOr <$> go x <*> go y + VIf t c x y -> VIf t c <$> go x <*> go y + expr -> tryUnblockBool expr go (throwUnexpectedlyBlockedError expr) + +negVectorEqSpine :: (MonadQueryStructure m) => WHNFSpine QueryBuiltin -> m (WHNFSpine QueryBuiltin) +negVectorEqSpine (VVecEqSpine a b n fn x y) = do + fn' <- appStdlibDef StdNotBoolOp2 [a, b, Arg mempty Explicit Relevant fn] + return $ VVecEqSpine a b n fn' x y +negVectorEqSpine spine = compilerDeveloperError $ "Malformed equality spine" <+> prettyVerbose spine + +throwUnexpectedlyBlockedError :: (MonadPropertyStructure m) => WHNFValue QueryBuiltin -> m a +throwUnexpectedlyBlockedError expr = do + let exprDoc = prettyVerbose expr + compilerDeveloperError ("Could not unblock blocked `not` on" <+> squotes exprDoc) diff --git a/vehicle/src/Vehicle/Backend/Queries/FourierMotzkinElimination.hs b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/FourierMotzkinElimination.hs similarity index 52% rename from vehicle/src/Vehicle/Backend/Queries/FourierMotzkinElimination.hs rename to vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/FourierMotzkinElimination.hs index d3199cc79..c0d4a4065 100644 --- a/vehicle/src/Vehicle/Backend/Queries/FourierMotzkinElimination.hs +++ b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/FourierMotzkinElimination.hs @@ -1,4 +1,4 @@ -module Vehicle.Backend.Queries.FourierMotzkinElimination +module Vehicle.Backend.Queries.UserVariableElimination.FourierMotzkinElimination ( FourierMotzkinVariableSolution, fourierMotzkinElimination, reconstructFourierMotzkinVariableValue, @@ -6,14 +6,13 @@ module Vehicle.Backend.Queries.FourierMotzkinElimination where import Control.Monad (foldM) -import Data.Set (Set) -import Data.Set qualified as Set (toList) -import Data.Vector qualified as Vector -import Vehicle.Backend.Queries.LinearExpr -import Vehicle.Backend.Queries.Variable +import Data.Map (Map) +import Vehicle.Backend.Queries.UserVariableElimination.Core (FourierMotzkinVariableSolution (..), RationalInequality (..)) import Vehicle.Compile.Error import Vehicle.Compile.Prelude -import Vehicle.Verify.Core +import Vehicle.Data.LinearExpr +import Vehicle.Syntax.Builtin (Strictness (..)) +import Vehicle.Verify.Variable -- | TODO If performance proves unnacceptably poor look into -- Imbert's acceleration theorems: @@ -23,61 +22,44 @@ import Vehicle.Verify.Core -- Artificial Intelligence IV: Methodology, Systems, Applications, 1990 fourierMotzkinElimination :: (MonadCompile m) => - Set MixedVariable -> - [FMAssertion] -> - m ([Solution], [FMAssertion]) -fourierMotzkinElimination varsToSolve assertions = - logCompilerPass MidDetail currentPass $ do - logDebug MaxDetail $ prettyAssertions assertions - let numberedVars = zip [1 ..] (Set.toList varsToSolve) - foldM solveVar ([], assertions) numberedVars - -type FMAssertion = Assertion MixedVariable - -type Solution = (MixedVariable, FourierMotzkinVariableSolution) - -solveVar :: - (MonadCompile m) => - ([Solution], [FMAssertion]) -> - (Int, MixedVariable) -> - m ([Solution], [FMAssertion]) -solveVar (solutions, inequalities) (iteration, var) = do - let (less, greater, unusedInequalities) = partition var inequalities - let solution = (var, FMSolution less greater) + UserRationalVariable -> + [RationalInequality] -> + m (FourierMotzkinVariableSolution, [RationalInequality]) +fourierMotzkinElimination var inequalities = do + let (less, greater, unusedInequalities) = partition (UserRationalVar var) inequalities + let solution = FMSolution less greater let newInequalities = fmap combineInequalities [(x, y) | x <- less, y <- greater] logDebug MaxDetail $ line - <> "After iteration" - <+> pretty iteration - <+> "solving for" + <> "After FM solving for" <+> pretty var <> ":" <> line <> indent 2 ( "LHS inequalities:" - <> prettyAssertions less + <> pretty less <> line <> "RHS inequalities:" - <> prettyAssertions greater + <> pretty greater <> line <> "New inequalities:" - <> prettyAssertions newInequalities + <> pretty newInequalities ) - return (solution : solutions, newInequalities <> unusedInequalities) + return (solution, newInequalities <> unusedInequalities) -combineInequalities :: (FMAssertion, FMAssertion) -> FMAssertion -combineInequalities (Assertion rel1 expr1, Assertion rel2 expr2) = +combineInequalities :: (RationalInequality, RationalInequality) -> RationalInequality +combineInequalities (RationalInequality rel1 expr1, RationalInequality rel2 expr2) = let rel = case (rel1, rel2) of - (LessThan, _) -> LessThan - (_, LessThan) -> LessThan - (_, _) -> LessThanOrEqualTo - in Assertion - { assertionExpr = addExprs 1 expr1 1 expr2, - assertionRel = rel + (Strict, _) -> Strict + (_, Strict) -> Strict + (_, _) -> NonStrict + in RationalInequality + { rationalIneqExpr = addExprs 1 1 expr1 expr2, + strictness = rel } -- | Partitions the inequalities into three sets: @@ -85,28 +67,28 @@ combineInequalities (Assertion rel1 expr1, Assertion rel2 expr2) = -- 2. Those where the rest of the expression is greater than the variable -- 3. Those which don't mention the variable at all. partition :: - MixedVariable -> - [FMAssertion] -> - ([FMAssertion], [FMAssertion], [FMAssertion]) + RationalVariable -> + [RationalInequality] -> + ([RationalInequality], [RationalInequality], [RationalInequality]) partition var = foldr categorise ([], [], []) where categorise :: - FMAssertion -> - ([FMAssertion], [FMAssertion], [FMAssertion]) -> - ([FMAssertion], [FMAssertion], [FMAssertion]) - categorise a@(Assertion rel expr) (less, greater, unused) = do + RationalInequality -> + ([RationalInequality], [RationalInequality], [RationalInequality]) -> + ([RationalInequality], [RationalInequality], [RationalInequality]) + categorise a@(RationalInequality rel expr) (less, greater, unused) = do let coeff = lookupCoefficient expr var if coeff < 0 then do let coeff' = -coeff let expr' = scaleExpr (1 / coeff') expr - let a' = Assertion rel expr' + let a' = RationalInequality rel expr' (a' : less, greater, unused) else if coeff > 0 then do let expr' = scaleExpr (1 / coeff) expr - let a' = Assertion rel expr' + let a' = RationalInequality rel expr' (less, a' : greater, unused) else (less, greater, a : unused) @@ -118,46 +100,42 @@ partition var = foldr categorise ([], [], []) -- required variable that is missing from the assignment or the reconstructed -- value. reconstructFourierMotzkinVariableValue :: - VariableAssignment MixedVariable -> + Map RationalVariable Rational -> FourierMotzkinVariableSolution -> - Either MixedVariable VariableValue + Either RationalVariable Rational reconstructFourierMotzkinVariableValue assignment solution = do - let size = 1 let inf = 1 / 0 let negInf = -1 / 0 - let initialMax = (Vector.replicate size negInf, LessThanOrEqualTo) - let initialMin = (Vector.replicate size inf, LessThanOrEqualTo) + let initialMax = (negInf, NonStrict) + let initialMin = (inf, NonStrict) (lowerBound, minRel) <- foldM evaluateMaxValue initialMax (lowerBounds solution) (upperBound, maxRel) <- foldM evaluateMinValue initialMin (upperBounds solution) - if lowerBound < upperBound || minRel == LessThanOrEqualTo && maxRel == LessThanOrEqualTo - then return $ addConstants 0.5 lowerBound 0.5 upperBound + if lowerBound < upperBound || minRel == NonStrict && maxRel == NonStrict + then return $ addConstants 0.5 0.5 lowerBound upperBound else -- Only 99% sure about this. Can't find a good reference to the reconstruction phase of the -- algorithm. Closest to referencing this impossibility is: -- https://people.math.carleton.ca/~kcheung/math/notes/MATH5801/02/2_1_fourier_motzkin.html developerError "Fourier-Motzkin reconstruction failed. This isn't supposed to be possible..." where evaluateMinValue :: - (Constant, Relation) -> - FMAssertion -> - Either MixedVariable (Constant, Relation) - evaluateMinValue current@(currentMin, _) (Assertion rel expr) = do + (Rational, Strictness) -> + RationalInequality -> + Either RationalVariable (Rational, Strictness) + evaluateMinValue current@(currentMin, _) (RationalInequality rel expr) = do value <- evaluateExpr expr assignment return $ - if (value < currentMin) || (value == currentMin && rel == LessThan) + if (value < currentMin) || (value == currentMin && rel == Strict) then (value, rel) else current evaluateMaxValue :: - (Constant, Relation) -> - FMAssertion -> - Either MixedVariable (Constant, Relation) - evaluateMaxValue current@(currentMax, _) (Assertion rel expr) = do + (Rational, Strictness) -> + RationalInequality -> + Either RationalVariable (Rational, Strictness) + evaluateMaxValue current@(currentMax, _) (RationalInequality rel expr) = do value <- evaluateExpr expr assignment return $ - if (value > currentMax) || (value == currentMax && rel == LessThan) + if (value > currentMax) || (value == currentMax && rel == Strict) then (value, rel) else current - -currentPass :: Doc a -currentPass = "Fourier-Motzkin elimination" diff --git a/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/Unblocking.hs b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/Unblocking.hs new file mode 100644 index 000000000..f3e01cb06 --- /dev/null +++ b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/Unblocking.hs @@ -0,0 +1,237 @@ +module Vehicle.Backend.Queries.UserVariableElimination.Unblocking + ( tryUnblockBool, + ) +where + +import Control.Monad.Reader (asks) +import Control.Monad.State (MonadState (..)) +import Control.Monad.Writer (MonadWriter (..)) +import Data.LinkedHashMap qualified as LinkedHashMap +import Data.Map qualified as Map +import Vehicle.Backend.Queries.UserVariableElimination.Core +import Vehicle.Compile.Context.Free (MonadFreeContext) +import Vehicle.Compile.Error +import Vehicle.Compile.Normalise.Builtin (traverseBuiltinBlockingArgs) +import Vehicle.Compile.Normalise.NBE +import Vehicle.Compile.Prelude +import Vehicle.Compile.Print (prettyFriendly) +import Vehicle.Compile.Resource (NetworkTensorType (..), NetworkType (..)) +import Vehicle.Compile.Type.Subsystem.Standard +import Vehicle.Data.BuiltinInterface.Value +import Vehicle.Data.NormalisedExpr +import Vehicle.Libraries.StandardLibrary.Definitions (StdLibFunction (StdAddVector, StdEqualsVector, StdNotEqualsVector, StdSubVector), findStdLibFunction) +import Vehicle.Verify.Core + +-------------------------------------------------------------------------------- +-- Main function + +tryUnblockBool :: + (MonadQueryStructure m, MonadWriter [WHNFValue QueryBuiltin] m) => + WHNFValue QueryBuiltin -> + (WHNFValue QueryBuiltin -> m a) -> + m a -> + m a +tryUnblockBool expr success failure = do + oldCtx <- getGlobalBoundCtx + logDebug MaxDetail $ line <> "Trying to unblock" <+> squotes (prettyFriendly (WithContext expr oldCtx)) + incrCallDepth + + unblockedExpr <- unblockExpr False expr + if expr /= unblockedExpr + then do + newCtx <- getGlobalBoundCtx + logDebug MaxDetail $ "Unblocked to" <+> squotes (prettyFriendly (WithContext unblockedExpr newCtx)) + decrCallDepth + success unblockedExpr + else do + logDebug MaxDetail "No progress made" + decrCallDepth + failure + +-------------------------------------------------------------------------------- +-- Recursive if-lifting operations + +type MonadUnblock m = (MonadQueryStructure m, MonadWriter [WHNFValue QueryBuiltin] m) + +type CompilingVecEq = Bool + +-- | Lifts all `if`s in the provided expression `e` to the top-level, while +-- preserving the guarantee that the expression is normalised as much as +-- possible. +-- Does not recurse into function type arguments for higher-order builtins +-- such as `map` and `fold`. +unblockExpr :: + (MonadUnblock m) => + CompilingVecEq -> + WHNFValue QueryBuiltin -> + m (WHNFValue QueryBuiltin) +unblockExpr compilingVecEq expr = case expr of + ---------------------- + -- Impossible cases -- + ---------------------- + VPi {} -> unexpectedTypeInExprError currentPass "Pi" + VUniverse {} -> unexpectedTypeInExprError currentPass "Universe" + VMeta {} -> unexpectedExprError currentPass "Meta" + -- The only way we can encounter a lambda in a normalised value is for + -- it to be present as the argument for a `map`/`fold`. However, we + -- explicitly don't recurse into those positions when we encounter those + -- builtins. + VLam {} -> unexpectedExprError currentPass "Lam" + ---------------- + -- Base cases -- + ---------------- + VBoolLiteral {} -> return expr + VAnd {} -> return expr + VOr {} -> return expr + VNot {} -> return expr + VIf {} -> return expr + VForall {} -> return expr + VExists {} -> return expr + ------------------ + -- Actual cases -- + ------------------ + VBoundVar lv [] + | compilingVecEq -> return $ VBoundVar lv [] + | otherwise -> unblockBoundVar lv + VFreeVar v spine -> unblockFreeVar compilingVecEq v spine + VBuiltin b spine -> unblockBuiltin compilingVecEq b spine + VBoundVar v spine -> do + ctx <- getGlobalBoundCtx + compilerDeveloperError $ + "Found bound variable with arguments:" + <> prettyFriendly (WithContext (VBoundVar v spine) ctx) + +unblockFreeVar :: + (MonadUnblock m) => + CompilingVecEq -> + Identifier -> + WHNFSpine QueryBuiltin -> + m (WHNFValue QueryBuiltin) +unblockFreeVar compilingVecEq ident spine = do + networkContext <- asks networkCtx + case Map.lookup (nameOf ident) networkContext of + Just networkInfo -> unblockNetwork ident networkInfo spine + _ -> case findStdLibFunction ident of + Just StdEqualsVector -> unblockVectorOp2 True StdEqualsVector spine + Just StdNotEqualsVector -> unblockVectorOp2 True StdNotEqualsVector spine + Just StdAddVector -> unblockVectorOp2 compilingVecEq StdAddVector spine + Just StdSubVector -> unblockVectorOp2 compilingVecEq StdSubVector spine + _ -> compilerDeveloperError $ "Unexpected free variable found while unblocking:" <+> pretty ident + +unblockNetwork :: (MonadUnblock m) => Identifier -> NetworkContextInfo -> WHNFSpine QueryBuiltin -> m (WHNFValue QueryBuiltin) +unblockNetwork ident networkInfo spine = do + unblockedSpine <- traverse (traverse (unblockExpr True)) spine + liftIfSpine unblockedSpine $ \unblockedSpine' -> + if unblockedSpine' /= unblockedSpine + then return $ VFreeVar ident unblockedSpine' + else do + let networkName = nameOf ident + let networkApp = (networkName, unblockedSpine') + globalCtx <- get + case spine of + [inputArg] -> case LinkedHashMap.lookup networkApp (networkApplications globalCtx) of + Just existingAppInfo -> + return $ outputVarExpr existingAppInfo + Nothing -> do + let (appInfo, newGlobalCtx) = addNetworkApplicationToGlobalCtx networkApp networkInfo globalCtx + let inputDims = dimensions (inputTensor (networkType networkInfo)) + let inputEquality = mkVVectorEquality inputDims (inputVarExpr appInfo) (argExpr inputArg) + put newGlobalCtx + tell [inputEquality] + return $ outputVarExpr appInfo + _ -> do + ctx <- getGlobalBoundCtx + compilerDeveloperError $ + "Found network application with multiple arguments:" + <> line + <> indent 2 (pretty networkName <> hsep (fmap (\arg -> prettyFriendly (WithContext (argExpr arg) ctx)) spine)) + +unblockVectorOp2 :: (MonadUnblock m) => CompilingVecEq -> StdLibFunction -> WHNFSpine QueryBuiltin -> m (WHNFValue QueryBuiltin) +unblockVectorOp2 compilingVecEq fn spine = do + unblockedSpine <- traverse (traverseExplicitArgExpr (unblockExpr compilingVecEq)) spine + liftIfSpine unblockedSpine $ \unblockedSpine' -> do + if compilingVecEq && isBlockedVectorSpine unblockedSpine' + then return $ VFreeVar (identifierOf fn) unblockedSpine' + else appStdlibDef fn unblockedSpine' + +isBlockedVectorSpine :: WHNFSpine QueryBuiltin -> Bool +isBlockedVectorSpine (reverse -> (argExpr -> VVecLiteral {}) : (argExpr -> VVecLiteral {}) : _) = False +isBlockedVectorSpine _ = True + +unblockBuiltin :: + (MonadUnblock m) => + CompilingVecEq -> + QueryBuiltin -> + WHNFSpine QueryBuiltin -> + m (WHNFValue QueryBuiltin) +unblockBuiltin compilingVecEq b spine = case VBuiltin b spine of + VAt _ _ xs i -> case distributeAt i xs of + Just distributed -> do logDebug MaxDetail "Shortcut!"; unblockExpr compilingVecEq =<< distributed + Nothing -> standard + _ -> standard + where + standard = do + unblockedSpine <- traverseBuiltinBlockingArgs (unblockExpr False) b spine + liftIfSpine unblockedSpine (evalBuiltin b) + +distributeAt :: forall m. (MonadFreeContext QueryBuiltin m) => WHNFValue QueryBuiltin -> WHNFValue QueryBuiltin -> Maybe (m (WHNFValue QueryBuiltin)) +distributeAt index = \case + VBuiltinFunction MapVector [t, _, n, f, xs] -> appIndex f [(t, n, xs)] + VBuiltinFunction ZipWithVector [t1, t2, _, n, f, xs, ys] -> appIndex f [(t1, n, xs), (t2, n, ys)] + VStandardLib StdAddVector [t1, t2, _, n, f, xs, ys] -> appIndex f [(t1, n, xs), (t2, n, ys)] + VStandardLib StdSubVector [t1, t2, _, n, f, xs, ys] -> appIndex f [(t1, n, xs), (t2, n, ys)] + _ -> Nothing + where + appIndex :: + WHNFArg QueryBuiltin -> + [(WHNFArg QueryBuiltin, WHNFArg QueryBuiltin, WHNFArg QueryBuiltin)] -> + Maybe (m (WHNFValue QueryBuiltin)) + appIndex f args = + Just $ + normaliseApp + (argExpr f) + ( flip fmap args $ \(t, n, xs) -> + Arg mempty Explicit Relevant (VAt t n (argExpr xs) index) + ) + +-------------------------------------------------------------------------------- +-- Basic if-lifting operations + +liftIf :: + (MonadCompile m) => + (WHNFValue QueryBuiltin -> m (WHNFValue QueryBuiltin)) -> + WHNFValue QueryBuiltin -> + m (WHNFValue QueryBuiltin) +liftIf k (VBuiltinFunction If [t, cond, e1, e2]) = do + e1' <- traverse (liftIf k) e1 + e2' <- traverse (liftIf k) e2 + return $ VBuiltinFunction If [t, cond, e1', e2'] +liftIf k e = k e + +liftIfArg :: + (MonadCompile m) => + (WHNFArg QueryBuiltin -> m (WHNFValue QueryBuiltin)) -> + WHNFArg QueryBuiltin -> + m (WHNFValue QueryBuiltin) +liftIfArg k (Arg p v r e) = liftIf (k . Arg p v r) e + +liftIfSpine :: + (MonadUnblock m) => + WHNFSpine QueryBuiltin -> + (WHNFSpine QueryBuiltin -> m (WHNFValue QueryBuiltin)) -> + m (WHNFValue QueryBuiltin) +liftIfSpine [] k = k [] +liftIfSpine (x : xs) k = liftIfArg (\a -> liftIfSpine xs (\as -> k (a : as))) x + +currentPass :: Doc a +currentPass = "if elimination" + +-------------------------------------------------------------------------------- +-- No network elimination + +unblockBoundVar :: (MonadQueryStructure m) => Lv -> m (WHNFValue QueryBuiltin) +unblockBoundVar lv = do + maybeReduction <- getReducedVariableExprFor lv + case maybeReduction of + Just vectorReduction -> return vectorReduction + Nothing -> return $ VBoundVar lv [] diff --git a/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/VariableReconstruction.hs b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/VariableReconstruction.hs new file mode 100644 index 000000000..aa8aa8fe1 --- /dev/null +++ b/vehicle/src/Vehicle/Backend/Queries/UserVariableElimination/VariableReconstruction.hs @@ -0,0 +1,154 @@ +module Vehicle.Backend.Queries.UserVariableElimination.VariableReconstruction where + +import Control.Monad (foldM) +import Data.Foldable (foldlM) +import Data.Map (Map) +import Data.Map qualified as Map +import Data.Map.Strict qualified as HashMap +import Data.Maybe (mapMaybe) +import Data.Vector qualified as Vector +import Vehicle.Backend.Queries.UserVariableElimination.Core +import Vehicle.Backend.Queries.UserVariableElimination.FourierMotzkinElimination +import Vehicle.Compile.Prelude +import Vehicle.Data.LinearExpr (RationalTensor (..), evaluateExpr) +import Vehicle.Verify.Variable + +-------------------------------------------------------------------------------- +-- Variable reconstruction + +reconstructUserVars :: + (MonadLogger m) => + UserVariableReconstruction -> + NetworkVariableAssignment -> + m UserVariableAssignment +reconstructUserVars steps networkVariableAssignment = + logCompilerPass MidDetail "recreation of user variables" $ do + let assignment = createInitialAssignment networkVariableAssignment + logDebug MaxDetail $ "Network variables:" <+> pretty networkVariableAssignment + alteredAssignment <- foldlM applyReconstructionStep assignment (reverse steps) + let finalAssignment = createFinalAssignment alteredAssignment + return finalAssignment + +-------------------------------------------------------------------------------- +-- Mixed variable assignments + +data MixedVariableAssignment = VariableAssignment + { tensorVariables :: Map TensorVariable RationalTensor, + rationalVariables :: Map RationalVariable Rational + } + +-- | Lookup the value of the variable in an assignment and remove it from the +-- assignment. +lookupAndRemoveRationalVariable :: + MixedVariableAssignment -> + RationalVariable -> + Maybe (Rational, MixedVariableAssignment) +lookupAndRemoveRationalVariable VariableAssignment {..} var = do + let (maybeValue, newRationalVariables) = Map.updateLookupWithKey (\_ _ -> Nothing) var rationalVariables + case maybeValue of + Nothing -> Nothing + Just value -> Just (value, VariableAssignment {rationalVariables = newRationalVariables, ..}) + +-- | Lookups the values in the variable assignment and removes them from the +-- assignment. Returns either the first missing variable or the list of values +-- and the resulting assignment. +lookupAndRemoveAll :: + MixedVariableAssignment -> + [RationalVariable] -> + Either RationalVariable ([Rational], MixedVariableAssignment) +lookupAndRemoveAll assignment = foldM op ([], assignment) + where + op (values, ass) var = case lookupAndRemoveRationalVariable ass var of + Nothing -> Left var + Just (value, ass') -> Right (value : values, ass') + +createInitialAssignment :: + NetworkVariableAssignment -> + MixedVariableAssignment +createInitialAssignment (NetworkVariableAssignment values) = do + VariableAssignment + { rationalVariables = HashMap.mapKeys NetworkRationalVar values, + tensorVariables = mempty + } + +applyReconstructionStep :: + (MonadLogger m) => + MixedVariableAssignment -> + UserVariableReconstructionStep -> + m MixedVariableAssignment +applyReconstructionStep assignment@VariableAssignment {..} step = + case step of + ReconstructTensor var individualVars -> + unreduceVariable (UserTensorVar var) (fmap UserRationalVar individualVars) assignment + SolveRationalEquality var eq -> do + logDebug MaxDetail $ "Reintroducing Gaussian solved variable" <+> quotePretty var + let errorOrValue = evaluateExpr (rationalEqExpr eq) rationalVariables + case errorOrValue of + Left missingVar -> developerError $ "Missing variable required in Gaussian elimination" <+> quotePretty missingVar + Right value -> + return $ + VariableAssignment + { rationalVariables = Map.insert (UserRationalVar var) value rationalVariables, + .. + } + SolveTensorEquality var eq -> do + logDebug MaxDetail $ "Reintroducing Gaussian solved variable" <+> quotePretty var + let errorOrValue = evaluateExpr (tensorEqExpr eq) tensorVariables + case errorOrValue of + Left missingVar -> developerError $ "Missing variable required in Gaussian elimination" <+> quotePretty missingVar + Right value -> + return $ + VariableAssignment + { tensorVariables = Map.insert (UserTensorVar var) value tensorVariables, + .. + } + SolveRationalInequalities var solution -> do + logDebug MaxDetail $ "Reintroducing Fourier-Motzkin solved variable" <+> pretty var + let errorOrValue = reconstructFourierMotzkinVariableValue rationalVariables solution + case errorOrValue of + Left missingVar -> developerError $ "Missing variable required in Fourier-Motzkin elimination" <+> quotePretty missingVar + Right value -> + return $ + VariableAssignment + { rationalVariables = Map.insert (UserRationalVar var) value rationalVariables, + .. + } + +-- | Unreduces a previously reduced variable, removing the normalised +-- values from the assignment and adding the unreduced value back to the +-- assignment. +unreduceVariable :: + (MonadLogger m) => + TensorVariable -> + [RationalVariable] -> + MixedVariableAssignment -> + m MixedVariableAssignment +unreduceVariable variable reducedVariables assignment@VariableAssignment {..} = do + let variableResults = lookupAndRemoveAll assignment reducedVariables + case variableResults of + Left missingVar -> + developerError $ + "When reconstructing variable" + <+> pretty variable + <+> "in counter-example," + <+> "unable to find variable" + <+> pretty missingVar + Right (values, newAssignment) -> do + logDebug MaxDetail $ + "Collapsing variables" <+> pretty reducedVariables <+> "to single variable" <+> pretty variable + let unreducedValue = RationalTensor (tensorVariableDims variable) (Vector.fromList values) + return $ + newAssignment + { tensorVariables = Map.insert variable unreducedValue tensorVariables + } + +createFinalAssignment :: + MixedVariableAssignment -> + UserVariableAssignment +createFinalAssignment (VariableAssignment {..}) = do + UserVariableAssignment $ mapMaybe getUserOriginalVariable (Map.toList tensorVariables) + where + getUserOriginalVariable :: (TensorVariable, RationalTensor) -> Maybe (OriginalUserVariable, RationalTensor) + getUserOriginalVariable (var, value) = case var of + NetworkTensorVar {} -> Nothing + UserTensorVar v -> Just (v, value) diff --git a/vehicle/src/Vehicle/Backend/Queries/Variable.hs b/vehicle/src/Vehicle/Backend/Queries/Variable.hs deleted file mode 100644 index 271705cb1..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/Variable.hs +++ /dev/null @@ -1,402 +0,0 @@ -{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} - -{-# HLINT ignore "Avoid lambda using `infix`" #-} -{-# HLINT ignore "Eta reduce" #-} -module Vehicle.Backend.Queries.Variable - ( Variable (..), - variableCtxToEnv, - UserVariable (..), - UserVariableCtx, - NetworkVariable (..), - NetworkVariableCtx, - sequentialNetworkVariableNaming, - MixedVariable (..), - isRationalVariable, - isUserVariable, - getUserVariable, - getNetworkVariable, - MixedVariables (..), - mixedVariableCtx, - mixedVariableDBCtx, - MixedVariableCtx, - Constant, - Coefficient, - scaleConstant, - prettyConstant, - addConstants, - constantExpr, - VariableValue, - VariableAssignment, - lookupAndRemoveAll, - pattern VInfiniteQuantifier, - pattern VFiniteQuantifier, - pattern VFiniteQuantifierSpine, - prettyRationalAsFloat, - variableCtxToBoundCtx, - ) -where - -import Control.Monad (foldM) -import Data.Aeson (FromJSON, FromJSONKey, ToJSON, ToJSONKey) -import Data.Bifunctor (Bifunctor (..)) -import Data.Char.SScript -import Data.Hashable (Hashable) -import Data.List.Split (chunksOf) -import Data.Map (Map) -import Data.Map qualified as Map -import Data.Text (Text, pack) -import Data.Text qualified as Text (pack) -import Data.Vector (Vector) -import Data.Vector qualified as Vector -import GHC.Generics (Generic) -import Numeric (showFFloat) -import Prettyprinter (brackets, list) -import Vehicle.Compile.Context.Bound.Core -import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.BuiltinInterface -import Vehicle.Data.DeBruijn -import Vehicle.Data.NormalisedExpr -import Vehicle.Libraries.StandardLibrary.Definitions (fromFiniteQuantifier, toFiniteQuantifier) -import Vehicle.Prelude -import Vehicle.Syntax.AST - --------------------------------------------------------------------------------- --- Variable class - -class - (Pretty variable, Eq variable, Ord variable, Hashable variable) => - Variable variable - where - variableDimensions :: variable -> TensorDimensions - - reduceVariable :: Lv -> variable -> ([variable], WHNFValue Builtin) - - toMixedVariable :: variable -> MixedVariable - -isRationalVariable :: (Variable variable) => variable -> Bool -isRationalVariable v = null (variableDimensions v) - -variableCtxToBoundCtxEntry :: (Variable variable) => Ix -> variable -> Binder Ix Builtin -variableCtxToBoundCtxEntry ix var = mkDefaultBinder (layoutAsText $ pretty var) (BoundVar mempty ix) - -variableCtxToBoundCtx :: (Variable variable) => [variable] -> BoundCtx Builtin -variableCtxToBoundCtx ctx = zipWith variableCtxToBoundCtxEntry [0 .. Ix (length ctx - 1)] ctx - -variableCtxToEnv :: (Variable variable) => [variable] -> Env strategy Builtin -variableCtxToEnv ctx = boundContextToEnv (variableCtxToBoundCtx ctx) - --------------------------------------------------------------------------------- --- User variables - --- | Variables entered by the user -data UserVariable = UserVariable - { userVarName :: Name, - userVarDimensions :: TensorDimensions, - unreducedUserVarName :: Name - } - deriving (Show, Eq, Ord, Generic) - -instance Pretty UserVariable where - pretty (UserVariable name _ _) = pretty name - -instance FromJSON UserVariable - -instance FromJSONKey UserVariable - -instance ToJSON UserVariable - -instance ToJSONKey UserVariable - -instance Hashable UserVariable - -instance Variable UserVariable where - variableDimensions = userVarDimensions - reduceVariable = reduceUserVariable - toMixedVariable = UserVar - -type UserVariableCtx = [UserVariable] - -reduceUserVariable :: Lv -> UserVariable -> (UserVariableCtx, WHNFValue Builtin) -reduceUserVariable dbLevel UserVariable {..} = do - let (vars, expr) = runSupply (go userVarName userVarDimensions) [dbLevel ..] - (reverse vars, expr) - where - go :: - Name -> - TensorDimensions -> - Supply Lv ([UserVariable], WHNFValue Builtin) - go name = \case - [] -> do - lv <- demand - return ([UserVariable name [] userVarName], VBoundVar lv []) - dim : dims -> do - -- Use the list monad to create a nested list of all possible indices into the tensor - let allIndices = [0 .. dim - 1] - - -- Generate the corresponding names from the indices - let mkName i = name <> "_" <> pack (show i) - (elementUserVars, subexprs) <- unzip <$> traverse (\i -> go (mkName i) dims) allIndices - - let userVars = concat elementUserVars - return (userVars, mkVLVec subexprs) - --------------------------------------------------------------------------------- --- Network variables - --- | Network input and output variables -data NetworkVariable = NetworkVariable - { -- | The name of the network this variable belongs to. - networkName :: Name, - -- | Records which number application of the network it is. - application :: Int, - -- | The dimensions of the variable - networkVarDimensions :: TensorDimensions, - -- | Whether its an input or an output variable - inputOrOutput :: InputOrOutput, - -- | The position of the input or output variable in the network application. - networkVarIndices :: Maybe Int - } - deriving (Show, Eq, Ord, Generic) - -instance ToJSON NetworkVariable - -instance FromJSON NetworkVariable - -instance Hashable NetworkVariable - -instance Pretty NetworkVariable where - pretty NetworkVariable {..} = - pretty networkName - <> pretty (fmap subscript (show application)) - <> brackets (pretty inputOrOutput) - <> maybe "" (\i -> "!" <> pretty i) networkVarIndices - -instance Variable NetworkVariable where - variableDimensions = networkVarDimensions - - reduceVariable = reduceNetworkVariable - - toMixedVariable = NetworkVar - -type NetworkVariableCtx = [NetworkVariable] - -reduceNetworkVariable :: Lv -> NetworkVariable -> (NetworkVariableCtx, WHNFValue Builtin) -reduceNetworkVariable dbLevel NetworkVariable {..} = do - let (vars, expr) = runSupply (go networkVarDimensions) [0 :: Int ..] - (reverse vars, expr) - where - go :: - (MonadSupply Int m) => - TensorDimensions -> - m ([NetworkVariable], WHNFValue Builtin) - go = \case - [] -> do - index <- demand - let var = NetworkVariable networkName application [] inputOrOutput (Just index) - let expr = VBoundVar (dbLevel + Lv index) [] - return ([var], expr) - dim : dims -> do - -- Generate the corresponding names from the indices - (elementUserVars, subexprs) <- unzip <$> traverse (const $ go dims) [0 .. dim - 1] - - let userVars = concat elementUserVars - return (userVars, mkVLVec subexprs) - -sequentialNetworkVariableNaming :: Text -> Text -> NetworkVariableCtx -> [Name] -sequentialNetworkVariableNaming inputPrefix outputPrefix variables = do - let (_, _, result) = foldl forNetwork (0, 0, []) (reverse variables) - result - where - forNetwork :: (Int, Int, [Name]) -> NetworkVariable -> (Int, Int, [Name]) - forNetwork (inputIndex, outputIndex, result) NetworkVariable {..} = - case inputOrOutput of - Input -> do - let name = inputPrefix <> Text.pack (show inputIndex) - (inputIndex + 1, outputIndex, name : result) - Output -> do - let name = outputPrefix <> Text.pack (show outputIndex) - (inputIndex, outputIndex + 1, name : result) - --------------------------------------------------------------------------------- --- All variables - --- | Both user and network variables -data MixedVariable - = UserVar UserVariable - | NetworkVar NetworkVariable - deriving (Show, Eq, Ord, Generic) - -instance ToJSON MixedVariable - -instance FromJSON MixedVariable - -instance ToJSONKey MixedVariable - -instance FromJSONKey MixedVariable - -instance Hashable MixedVariable - -instance Pretty MixedVariable where - pretty = \case - UserVar v -> pretty v - NetworkVar v -> pretty v - -instance Variable MixedVariable where - variableDimensions = \case - UserVar v -> variableDimensions v - NetworkVar v -> variableDimensions v - - reduceVariable dbLevel = \case - UserVar v -> first (fmap UserVar) $ reduceUserVariable dbLevel v - NetworkVar v -> first (fmap NetworkVar) $ reduceNetworkVariable dbLevel v - - toMixedVariable = id - -isUserVariable :: MixedVariable -> Bool -isUserVariable = \case - UserVar {} -> True - NetworkVar {} -> False - -getNetworkVariable :: MixedVariable -> Maybe NetworkVariable -getNetworkVariable = \case - UserVar {} -> Nothing - NetworkVar v -> Just v - -getUserVariable :: MixedVariable -> Maybe UserVariable -getUserVariable = \case - UserVar v -> Just v - NetworkVar {} -> Nothing - -type MixedVariableCtx = [MixedVariable] - -data MixedVariables = MixedVariables - { userVariableCtx :: UserVariableCtx, - networkVariableCtx :: NetworkVariableCtx - } - -instance Pretty MixedVariables where - pretty (MixedVariables userVars networkVars) = - "U" <> pretty userVars <> " N" <> pretty networkVars - -mixedVariableCtx :: MixedVariables -> MixedVariableCtx -mixedVariableCtx MixedVariables {..} = - fmap NetworkVar networkVariableCtx <> fmap UserVar userVariableCtx - -mixedVariableDBCtx :: MixedVariables -> BoundCtx Builtin -mixedVariableDBCtx ctx = variableCtxToBoundCtx (mixedVariableCtx ctx) - --------------------------------------------------------------------------------- --- Constants - -type Coefficient = Rational - -type Constant = Vector Rational - -scaleConstant :: Rational -> Constant -> Constant -scaleConstant v = Vector.map (v *) - -addConstants :: Coefficient -> Constant -> Coefficient -> Constant -> Constant -addConstants a xs b ys = Vector.zipWith (\x y -> a * x + b * y) xs ys - -foldConstant :: forall a. (Rational -> a) -> ([a] -> a) -> TensorDimensions -> Constant -> a -foldConstant mkValue mkVec dims value = go dims (Vector.toList value) - where - go :: TensorDimensions -> [Rational] -> a - go [] xs = mkValue (head xs) - go (_d : ds) xs = do - let inputVarIndicesChunks = chunksOf (product ds) xs - let elems = fmap (go ds) inputVarIndicesChunks - mkVec elems - -constantExpr :: TensorDimensions -> Constant -> WHNFValue Builtin -constantExpr = foldConstant (VRatLiteral . toRational) mkVLVec - --- | Pretty prints a constant value given a set of dimensions. --- Note, an alternative would be to go via the Vehicle AST and pretty print --- that, but we run into dependency cycle issues. -prettyConstant :: Bool -> TensorDimensions -> Constant -> Doc a -prettyConstant isFirst dims value - | not isFirst && Vector.all (== 0.0) value = "" - | not isFirst = " + " <> foldConstant pretty list dims value - | otherwise = foldConstant pretty list dims value - -prettyRationalAsFloat :: Rational -> Doc a -prettyRationalAsFloat p = do - let f = realToFrac p :: Double - pretty $ showFFloat Nothing f "" - --------------------------------------------------------------------------------- --- Variable assignments - --- | A single value assigned to a variable. The dimensions of the value are --- stored by the accompanying `Variable`. -type VariableValue = Constant - -type VariableAssignment variable = Map variable VariableValue - --- | Lookup the value of the variable in an assignment and remove it from the --- assignment. -lookupAndRemove :: - (Variable variable) => - VariableAssignment variable -> - variable -> - Maybe (VariableValue, VariableAssignment variable) -lookupAndRemove assignment var = do - let (maybeValue, newAssignment) = Map.updateLookupWithKey (\_ _ -> Nothing) var assignment - case maybeValue of - Nothing -> Nothing - Just value -> Just (value, newAssignment) - --- | Lookups the values in the variable assignment and removes them from the --- assignment. Returns either the first missing variable or the list of values --- and the resulting assignment. -lookupAndRemoveAll :: - (Variable variable) => - VariableAssignment variable -> - [variable] -> - Either variable ([VariableValue], VariableAssignment variable) -lookupAndRemoveAll assignment = foldM op ([], assignment) - where - op (values, ass) var = case lookupAndRemove ass var of - Nothing -> Left var - Just (value, ass') -> Right (value : values, ass') - --------------------------------------------------------------------------------- --- Other - -pattern VInfiniteQuantifier :: - Quantifier -> - [WHNFArg Builtin] -> - WHNFBinder Builtin -> - WHNFEnv Builtin -> - Expr Ix Builtin -> - WHNFValue Builtin -pattern VInfiniteQuantifier q args binder env body <- - VBuiltin (BuiltinFunction (Quantifier q)) (reverse -> RelevantExplicitArg _ (VLam binder (WHNFBody env body)) : args) - where - VInfiniteQuantifier q args binder env body = - VBuiltin (BuiltinFunction (Quantifier q)) (reverse (Arg mempty Explicit Relevant (VLam binder (WHNFBody env body)) : args)) - -pattern VFiniteQuantifier :: - Quantifier -> - WHNFSpine Builtin -> - WHNFBinder Builtin -> - WHNFEnv Builtin -> - Expr Ix Builtin -> - WHNFValue Builtin -pattern VFiniteQuantifier q spine binder env body <- - VFreeVar (toFiniteQuantifier -> Just q) (VFiniteQuantifierSpine spine binder env body) - where - VFiniteQuantifier q spine binder env body = - VFreeVar (fromFiniteQuantifier q) (VFiniteQuantifierSpine spine binder env body) - -pattern VFiniteQuantifierSpine :: - WHNFSpine Builtin -> - WHNFBinder Builtin -> - WHNFEnv Builtin -> - Expr Ix Builtin -> - WHNFSpine Builtin -pattern VFiniteQuantifierSpine spine binder env body <- (reverse -> RelevantExplicitArg _ (VLam binder (WHNFBody env body)) : spine) - where - VFiniteQuantifierSpine spine binder env body = - reverse (Arg mempty Explicit Relevant (VLam binder (WHNFBody env body)) : spine) diff --git a/vehicle/src/Vehicle/Backend/Queries/VariableReconstruction.hs b/vehicle/src/Vehicle/Backend/Queries/VariableReconstruction.hs deleted file mode 100644 index e372ace9e..000000000 --- a/vehicle/src/Vehicle/Backend/Queries/VariableReconstruction.hs +++ /dev/null @@ -1,95 +0,0 @@ -module Vehicle.Backend.Queries.VariableReconstruction where - -import Data.Foldable (foldlM) -import Data.Map qualified as Map -import Data.Vector qualified as Vector -import Vehicle.Backend.Queries.FourierMotzkinElimination -import Vehicle.Backend.Queries.GaussianElimination -import Vehicle.Backend.Queries.Variable -import Vehicle.Compile.Prelude -import Vehicle.Verify.Core - --------------------------------------------------------------------------------- --- Variable reconstruction - -reconstructUserVars :: - (MonadLogger m) => - MetaNetwork -> - VariableNormalisationSteps -> - NetworkVariableAssignment -> - m UserVariableAssignment -reconstructUserVars metaNetwork steps networkVariableAssignment = - logCompilerPass MidDetail "recreation of user variables" $ do - let assignment = createInitialAssignment metaNetwork networkVariableAssignment - logDebug MaxDetail $ "Network variables:" <+> pretty (Map.keys assignment) - finalAssignment <- foldlM applyReconstructionStep assignment (reverse steps) - let assignmentPairs = traverse checkIsUserVariable $ Map.toList finalAssignment - case assignmentPairs of - Right pairs -> - return $ UserVariableAssignment pairs - Left networkVar -> - developerError $ "Did not successfully eliminate network variable" <+> pretty networkVar - -createInitialAssignment :: - MetaNetwork -> - NetworkVariableAssignment -> - VariableAssignment MixedVariable -createInitialAssignment metaNetwork (NetworkVariableAssignment values) = do - let networkVariables = metaNetworkVariables True metaNetwork - let mkEntry var value = (NetworkVar var, Vector.singleton value) - let variableValuePairs = zipWith mkEntry networkVariables (Vector.toList values) - Map.fromList variableValuePairs - -applyReconstructionStep :: - (MonadLogger m) => - VariableAssignment MixedVariable -> - VariableNormalisationStep -> - m (VariableAssignment MixedVariable) -applyReconstructionStep assignment step = - case step of - Reduce var -> unreduceVariable var assignment - Introduce var -> do - logDebug MaxDetail $ "Deleting now unused variable" <+> quotePretty var - return $ Map.delete var assignment - EliminateViaGaussian var solution -> do - logDebug MaxDetail $ "Reintroducing Gaussian solved variable" <+> quotePretty var - let errorOrValue = reconstructGaussianVariableValue assignment solution - case errorOrValue of - Left missingVar -> developerError $ "Missing variable required in Gaussian elimination" <+> quotePretty missingVar - Right value -> return $ Map.insert var value assignment - EliminateViaFourierMotzkin var solution -> do - logDebug MaxDetail $ "Reintroducing Fourier-Motzkin solved variable" <+> pretty var - let errorOrValue = reconstructFourierMotzkinVariableValue assignment solution - case errorOrValue of - Left missingVar -> developerError $ "Missing variable required in Fourier-Motzkin elimination" <+> quotePretty missingVar - Right value -> return $ Map.insert var value assignment - --- | Unreduces a previously reduced variable, removing the normalised --- values from the assignment and adding the unreduced value back to the --- assignment. -unreduceVariable :: - (MonadLogger m) => - MixedVariable -> - VariableAssignment MixedVariable -> - m (VariableAssignment MixedVariable) -unreduceVariable variable assignment = do - let reducedVariables = fst $ reduceVariable 0 variable - let variableResults = lookupAndRemoveAll assignment reducedVariables - case variableResults of - Left missingVar -> - developerError $ - "When reconstructing variable" - <+> pretty variable - <+> "in counter-example," - <+> "unable to find variable" - <+> pretty missingVar - Right (values, assignment') -> do - logDebug MaxDetail $ - "Collapsing variables" <+> pretty reducedVariables <+> "to single variable" <+> pretty variable - let unreducedValue = Vector.concat values - return $ Map.insert variable unreducedValue assignment' - -checkIsUserVariable :: (MixedVariable, Constant) -> Either NetworkVariable (UserVariable, Constant) -checkIsUserVariable (var, value) = case var of - NetworkVar v -> Left v - UserVar v -> Right (v, value) diff --git a/vehicle/src/Vehicle/CommandLine.hs b/vehicle/src/Vehicle/CommandLine.hs index 74c4759f6..61c1d90dd 100644 --- a/vehicle/src/Vehicle/CommandLine.hs +++ b/vehicle/src/Vehicle/CommandLine.hs @@ -72,8 +72,6 @@ data Options = Options data GlobalOptions = GlobalOptions { version :: Bool, - outFile :: Maybe FilePath, - errFile :: Maybe FilePath, logFile :: Maybe FilePath, loggingLevel :: LoggingLevel } @@ -83,8 +81,6 @@ defaultGlobalOptions :: GlobalOptions defaultGlobalOptions = GlobalOptions { version = False, - outFile = Nothing, - errFile = Nothing, logFile = Nothing, loggingLevel = defaultLoggingLevel } @@ -152,8 +148,6 @@ globalOptionsParser :: Parser GlobalOptions globalOptionsParser = GlobalOptions <$> showVersionParser - <*> redirectStdoutParser - <*> redirectStderrParser <*> redirectLogsParser <*> loggingLevelParser @@ -319,28 +313,6 @@ showVersionParser = <> short 'v' <> help "Show version information." -redirectStdoutParser :: Parser (Maybe FilePath) -redirectStdoutParser = - optional $ - strOption $ - long "redirect-stdout" - <> internal - <> metavar "FILE" - <> help - "Redirects the standard output to the provided file. \ - \ If no argument is provided will default to stdout." - -redirectStderrParser :: Parser (Maybe FilePath) -redirectStderrParser = - optional $ - strOption $ - long "redirect-stderr" - <> internal - <> metavar "FILE" - <> help - "Redirects the standard error to the provided file. \ - \ If no argument is provided will default to stderr." - redirectLogsParser :: Parser (Maybe FilePath) redirectLogsParser = optional $ diff --git a/vehicle/src/Vehicle/Compile.hs b/vehicle/src/Vehicle/Compile.hs index 022d782df..b0d555055 100644 --- a/vehicle/src/Vehicle/Compile.hs +++ b/vehicle/src/Vehicle/Compile.hs @@ -5,7 +5,6 @@ module Vehicle.Compile where import Control.Monad (unless) -import Control.Monad.IO.Class (MonadIO (..)) import Data.Hashable (Hashable) import Data.Map qualified as Map import Vehicle.Backend.Agda @@ -25,7 +24,7 @@ import Vehicle.Compile.Type.Irrelevance (removeIrrelevantCodeFromProg) import Vehicle.Compile.Type.Subsystem (resolveInstanceArguments) import Vehicle.Compile.Type.Subsystem.Standard import Vehicle.Data.BuiltinInterface -import Vehicle.Prelude.Warning (CompileWarning (ResourcesUnnecessariyProvidedForBackend)) +import Vehicle.Prelude.Warning (CompileWarning (..)) import Vehicle.TypeCheck (TypeCheckOptions (..), runCompileMonad, typeCheckUserProg) import Vehicle.Verify.QueryFormat @@ -46,7 +45,7 @@ data CompileOptions = CompileOptions } deriving (Eq, Show) -compile :: LoggingSettings -> CompileOptions -> IO () +compile :: (MonadStdIO IO) => LoggingSettings -> CompileOptions -> IO () compile loggingSettings options@CompileOptions {..} = runCompileMonad loggingSettings $ do (imports, prog) <- typeCheckUserProg $ @@ -73,7 +72,7 @@ compile loggingSettings options@CompileOptions {..} = runCompileMonad loggingSet -- Backend-specific compilation functions compileToQueryFormat :: - (MonadCompile m, MonadIO m) => + (MonadCompile m, MonadStdIO m) => (Imports, Prog Ix Builtin) -> Resources -> QueryFormatID -> @@ -85,7 +84,7 @@ compileToQueryFormat (imports, typedProg) resources queryFormatID output = do compileToQueries verifier mergedProg resources output compileToAgda :: - (MonadCompile m, MonadIO m) => + (MonadCompile m, MonadStdIO m) => CompileOptions -> (Imports, Prog Ix Builtin) -> m () @@ -96,7 +95,7 @@ compileToAgda options@CompileOptions {..} (_, typedProg) = do writeAgdaFile output agdaCode compileToLossFunction :: - (MonadCompile m, MonadIO m) => + (MonadCompile m, MonadStdIO m) => (Imports, Prog Ix Builtin) -> DifferentiableLogicID -> Maybe FilePath -> @@ -109,7 +108,7 @@ compileToLossFunction (imports, typedProg) differentiableLogic output outputAsJS compileToTensors lossProg output outputAsJSON compileDirect :: - (MonadCompile m, MonadIO m) => + (MonadCompile m, MonadStdIO m) => (Imports, Prog Ix Builtin) -> Maybe FilePath -> Bool -> @@ -121,7 +120,7 @@ compileDirect (imports, typedProg) outputFile outputAsJSON = do compileToTensors :: forall builtin m. - (MonadCompile m, MonadIO m, HasStandardData builtin, TypableBuiltin builtin, Hashable builtin, ToJBuiltin builtin) => + (MonadCompile m, MonadStdIO m, HasStandardData builtin, TypableBuiltin builtin, Hashable builtin, ToJBuiltin builtin) => Prog Ix builtin -> Maybe FilePath -> Bool -> @@ -151,4 +150,4 @@ warnIfResourcesProvided CompileOptions {..} = do let networks = fmap (Network,) (Map.keys networkLocations) let resources = parameters <> datasets <> networks unless (null resources) $ do - logWarning $ ResourcesUnnecessariyProvidedForBackend target resources + logWarning $ UnnecessaryResourcesProvided target resources diff --git a/vehicle/src/Vehicle/Compile/Context/Bound/Instance.hs b/vehicle/src/Vehicle/Compile/Context/Bound/Instance.hs index 77c201d05..51d52dcfc 100644 --- a/vehicle/src/Vehicle/Compile/Context/Bound/Instance.hs +++ b/vehicle/src/Vehicle/Compile/Context/Bound/Instance.hs @@ -53,6 +53,7 @@ instance (MonadLogger m) => MonadLogger (BoundContextT builtin m) where decrCallDepth = BoundContextT decrCallDepth getDebugLevel = BoundContextT getDebugLevel logMessage = BoundContextT . logMessage + logWarning = BoundContextT . logWarning instance (MonadError e m) => MonadError e (BoundContextT builtin m) where throwError = lift . throwError diff --git a/vehicle/src/Vehicle/Compile/Context/Free.hs b/vehicle/src/Vehicle/Compile/Context/Free.hs index f51ec2297..d190e8165 100644 --- a/vehicle/src/Vehicle/Compile/Context/Free.hs +++ b/vehicle/src/Vehicle/Compile/Context/Free.hs @@ -1,5 +1,16 @@ -module Vehicle.Compile.Context.Free (module X) where +module Vehicle.Compile.Context.Free + ( module X, + addDeclToContext, + ) +where import Vehicle.Compile.Context.Free.Class as X import Vehicle.Compile.Context.Free.Core as X import Vehicle.Compile.Context.Free.Instance as X +import Vehicle.Compile.Normalise.NBE +import Vehicle.Compile.Prelude + +addDeclToContext :: (MonadFreeContext builtin m) => Decl Ix builtin -> m a -> m a +addDeclToContext decl k = do + normDecl <- traverse normaliseInEmptyEnv decl + addDeclEntryToContext (normDecl, typeOf decl) k diff --git a/vehicle/src/Vehicle/Compile/Context/Free/Class.hs b/vehicle/src/Vehicle/Compile/Context/Free/Class.hs index de8bb9754..bcf010a3f 100644 --- a/vehicle/src/Vehicle/Compile/Context/Free/Class.hs +++ b/vehicle/src/Vehicle/Compile/Context/Free/Class.hs @@ -1,5 +1,6 @@ module Vehicle.Compile.Context.Free.Class where +import Control.Monad.Identity (IdentityT, mapIdentityT) import Control.Monad.Reader (ReaderT (..), mapReaderT) import Control.Monad.State (StateT (..), mapStateT) import Control.Monad.Writer @@ -10,6 +11,7 @@ import Vehicle.Compile.Error (MonadCompile, lookupInFreeCtx) import Vehicle.Compile.Prelude import Vehicle.Compile.Print (PrintableBuiltin) import Vehicle.Data.BuiltinInterface (HasStandardData) +import Vehicle.Data.NormalisedExpr (WHNFDecl) -------------------------------------------------------------------------------- -- Context monad class @@ -17,42 +19,63 @@ import Vehicle.Data.BuiltinInterface (HasStandardData) -- | A monad that is used to store the current context at a given point in a -- program, i.e. what declarations and bound variables are in scope. class (PrintableBuiltin builtin, HasStandardData builtin, MonadCompile m) => MonadFreeContext builtin m where - addDeclToContext :: Decl Ix builtin -> m a -> m a - getFreeCtx :: Proxy builtin -> m (FreeCtx builtin) + addDeclEntryToContext :: (WHNFDecl builtin, Type Ix builtin) -> m a -> m a + getFreeCtx :: Proxy builtin -> m (GenericFreeCtx (WHNFDecl builtin, Type Ix builtin)) locallyAdjustCtx :: Proxy builtin -> (FreeCtx builtin -> FreeCtx builtin) -> m a -> m a instance (Monoid w, MonadFreeContext builtin m) => MonadFreeContext builtin (WriterT w m) where - addDeclToContext = mapWriterT . addDeclToContext + addDeclEntryToContext = mapWriterT . addDeclEntryToContext getFreeCtx = lift . getFreeCtx locallyAdjustCtx p = mapWriterT . locallyAdjustCtx p instance (MonadFreeContext builtin m) => MonadFreeContext builtin (ReaderT w m) where - addDeclToContext = mapReaderT . addDeclToContext + addDeclEntryToContext = mapReaderT . addDeclEntryToContext getFreeCtx = lift . getFreeCtx locallyAdjustCtx p = mapReaderT . locallyAdjustCtx p instance (MonadFreeContext builtin m) => MonadFreeContext builtin (StateT w m) where - addDeclToContext = mapStateT . addDeclToContext + addDeclEntryToContext = mapStateT . addDeclEntryToContext getFreeCtx = lift . getFreeCtx locallyAdjustCtx p = mapStateT . locallyAdjustCtx p instance (MonadFreeContext builtin m) => MonadFreeContext builtin (BoundContextT builtin m) where - addDeclToContext = mapBoundContextT . addDeclToContext + addDeclEntryToContext = mapBoundContextT . addDeclEntryToContext getFreeCtx = lift . getFreeCtx locallyAdjustCtx p = mapBoundContextT . locallyAdjustCtx p +instance (MonadFreeContext builtin m) => MonadFreeContext builtin (IdentityT m) where + addDeclEntryToContext = mapIdentityT . addDeclEntryToContext + getFreeCtx = lift . getFreeCtx + locallyAdjustCtx p = mapIdentityT . locallyAdjustCtx p + +instance (MonadFreeContext builtin m) => MonadFreeContext builtin (SupplyT s m) where + addDeclEntryToContext = mapSupplyT . addDeclEntryToContext + getFreeCtx = lift . getFreeCtx + locallyAdjustCtx p = mapSupplyT . locallyAdjustCtx p + -------------------------------------------------------------------------------- -- Operations +getDeclEntry :: + forall builtin m. + (MonadFreeContext builtin m) => + Proxy builtin -> + CompilerPass -> + Identifier -> + m (WHNFDecl builtin, Type Ix builtin) +getDeclEntry proxy compilerPass ident = do + ctx <- getFreeCtx proxy + lookupInFreeCtx compilerPass ident ctx + getDecl :: forall builtin m. (MonadFreeContext builtin m) => Proxy builtin -> CompilerPass -> Identifier -> - m (Decl Ix builtin) -getDecl _ compilerPass ident = - lookupInFreeCtx compilerPass ident =<< getFreeCtx (Proxy @builtin) + m (WHNFDecl builtin) +getDecl proxy compilerPass ident = + fst <$> getDeclEntry proxy compilerPass ident getDeclType :: (MonadFreeContext builtin m) => @@ -60,6 +83,5 @@ getDeclType :: CompilerPass -> Identifier -> m (Type Ix builtin) -getDeclType proxy compilerPass ident = do - decl <- getDecl proxy compilerPass ident - return $ typeOf decl +getDeclType proxy compilerPass ident = + snd <$> getDeclEntry proxy compilerPass ident diff --git a/vehicle/src/Vehicle/Compile/Context/Free/Core.hs b/vehicle/src/Vehicle/Compile/Context/Free/Core.hs index ebc60eab1..047a0de91 100644 --- a/vehicle/src/Vehicle/Compile/Context/Free/Core.hs +++ b/vehicle/src/Vehicle/Compile/Context/Free/Core.hs @@ -2,10 +2,11 @@ module Vehicle.Compile.Context.Free.Core where import Data.Map (Map) import Vehicle.Data.DeBruijn (Ix) +import Vehicle.Data.NormalisedExpr import Vehicle.Syntax.AST -- | Stores information associated with the declarations that are currently in -- scope, indexed into via their names. type GenericFreeCtx a = Map Identifier a -type FreeCtx builtin = GenericFreeCtx (Decl Ix builtin) +type FreeCtx builtin = GenericFreeCtx (WHNFDecl builtin, Type Ix builtin) diff --git a/vehicle/src/Vehicle/Compile/Context/Free/Instance.hs b/vehicle/src/Vehicle/Compile/Context/Free/Instance.hs index 29e0648ad..7dee0c448 100644 --- a/vehicle/src/Vehicle/Compile/Context/Free/Instance.hs +++ b/vehicle/src/Vehicle/Compile/Context/Free/Instance.hs @@ -13,6 +13,7 @@ import Vehicle.Compile.Error (MonadCompile) import Vehicle.Compile.Prelude import Vehicle.Compile.Print (PrintableBuiltin) import Vehicle.Data.BuiltinInterface (HasStandardData) +import Vehicle.Prelude.IO qualified as VIO -------------------------------------------------------------------------------- -- Free variable context monad instantiation @@ -53,6 +54,7 @@ instance (MonadLogger m) => MonadLogger (FreeContextT builtin m) where decrCallDepth = FreeContextT decrCallDepth getDebugLevel = FreeContextT getDebugLevel logMessage = FreeContextT . logMessage + logWarning = FreeContextT . logWarning instance (MonadError e m) => MonadError e (FreeContextT builtin m) where throwError = lift . throwError @@ -69,6 +71,12 @@ instance (MonadReader s m) => MonadReader s (FreeContextT builtin m) where instance (MonadIO m) => MonadIO (FreeContextT builtin m) where liftIO = lift . liftIO +instance (MonadStdIO m) => MonadStdIO (FreeContextT builtin m) where + writeStdout = lift . VIO.writeStdout + writeStderr = lift . VIO.writeStderr + writeStdoutLn = lift . VIO.writeStdoutLn + writeStderrLn = lift . VIO.writeStderrLn + -------------------------------------------------------------------------------- -- Context monad preservation @@ -76,8 +84,8 @@ instance (PrintableBuiltin builtin, HasStandardData builtin, MonadCompile m) => MonadFreeContext builtin (FreeContextT builtin m) where - addDeclToContext decl cont = FreeContextT $ do - let updateCtx = Map.insert (identifierOf decl) decl + addDeclEntryToContext entry@(decl, _) cont = FreeContextT $ do + let updateCtx = Map.insert (identifierOf decl) entry local updateCtx (unFreeContextT cont) getFreeCtx _ = FreeContextT ask diff --git a/vehicle/src/Vehicle/Compile/Error.hs b/vehicle/src/Vehicle/Compile/Error.hs index 487b911c9..f818a6f96 100644 --- a/vehicle/src/Vehicle/Compile/Error.hs +++ b/vehicle/src/Vehicle/Compile/Error.hs @@ -3,8 +3,7 @@ module Vehicle.Compile.Error where import Control.Exception (IOException) -import Control.Monad.Except (MonadError, runExceptT, throwError) -import Control.Monad.Trans.Except (ExceptT) +import Control.Monad.Except (MonadError, throwError) import Data.List.NonEmpty (NonEmpty) import Data.Map qualified as Map import Prettyprinter (list) @@ -28,20 +27,13 @@ type MonadCompile m = MonadError CompileError m ) -runCompileMonadSilently :: Doc x -> ExceptT CompileError SilentLogger a -> a -runCompileMonadSilently action v = do - let r = runSilentLogger $ runExceptT v - case r of - Left err -> developerError $ "Error thrown while" <+> action <> ":" <+> pretty (show err) - Right s -> s - -------------------------------------------------------------------------------- -- Compilation errors data CompileError = DevError (Doc ()) | -- Parse errors - ParseError ParseError + ParseError Module ParseError | -- Command line option errors InvalidPrunedName Name | -- Errors thrown by scope checking. diff --git a/vehicle/src/Vehicle/Compile/Error/Message.hs b/vehicle/src/Vehicle/Compile/Error/Message.hs index fec75f499..a1704d8de 100644 --- a/vehicle/src/Vehicle/Compile/Error/Message.hs +++ b/vehicle/src/Vehicle/Compile/Error/Message.hs @@ -20,7 +20,8 @@ import Vehicle.Compile.Prelude import Vehicle.Compile.Print import Vehicle.Compile.Type.Core import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr (pattern UnitLiteral) +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.DSL import Vehicle.Data.DeBruijn (substDBInto) import Vehicle.Data.NormalisedExpr @@ -90,7 +91,7 @@ instance MeaningfulError CompileError where -- Parsing -- ------------- - ParseError parseError -> case parseError of + ParseError _module parseError -> case parseError of RawParseError text -> EError $ ExternalError diff --git a/vehicle/src/Vehicle/Compile/ExpandResources.hs b/vehicle/src/Vehicle/Compile/ExpandResources.hs index 8cc2ca5ef..4623ec835 100644 --- a/vehicle/src/Vehicle/Compile/ExpandResources.hs +++ b/vehicle/src/Vehicle/Compile/ExpandResources.hs @@ -7,7 +7,7 @@ import Control.Monad import Control.Monad.Except import Control.Monad.Reader import Control.Monad.State -import Control.Monad.Writer (MonadWriter, WriterT (..), tell) +import Control.Monad.Writer (WriterT (..), tell) import Data.Map (Map) import Data.Map qualified as Map import Data.Maybe (maybeToList) @@ -19,11 +19,10 @@ import Vehicle.Compile.ExpandResources.Dataset import Vehicle.Compile.ExpandResources.Network import Vehicle.Compile.ExpandResources.Parameter import Vehicle.Compile.Normalise.NBE (normaliseInEmptyEnv) -import Vehicle.Compile.Normalise.Quote (unnormalise) import Vehicle.Compile.Prelude import Vehicle.Compile.Print.Warning () import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr import Vehicle.Prelude.Warning (CompileWarning (..)) @@ -37,8 +36,8 @@ expandResources :: m (Prog Ix Builtin, NetworkContext, FreeCtx Builtin, ResourcesIntegrityInfo) expandResources resources prog = logCompilerPass MinDetail "expansion of external resources" $ do - ((progWithoutResources, (networkCtx, inferableParameterCtx)), partialFreeCtx) <- - runFreeContextT @m @Builtin mempty (runWriterT (runStateT (runReaderT (readResourcesInProg prog) resources) (mempty, mempty))) + ((progWithoutResources, (networkCtx, inferableParameterCtx, _explicitParameterCtx)), partialFreeCtx) <- + runFreeContextT @m @Builtin mempty (runWriterT (runStateT (runReaderT (readResourcesInProg prog) resources) (mempty, mempty, mempty))) checkForUnusedResources resources partialFreeCtx @@ -46,27 +45,20 @@ expandResources resources prog = integrityInfo <- generateResourcesIntegrityInfo resources return (progWithoutResources, networkCtx, freeCtx, integrityInfo) -mkFunctionDefFromResource :: Provenance -> Identifier -> WHNFValue Builtin -> Decl Ix Builtin +mkFunctionDefFromResource :: Provenance -> Identifier -> WHNFValue Builtin -> (WHNFDecl Builtin, Type Ix Builtin) mkFunctionDefFromResource p ident value = do -- We're doing something wrong here as we only really need the value. -- We should really be storing the parameter values in their own environment, -- as values rather than as declarations in the free var context. - let gluedType = Builtin mempty (BuiltinType Unit) - let gluedExpr = unnormalise 0 value - DefFunction p ident mempty gluedType gluedExpr + let unnormType = Builtin mempty (BuiltinType Unit) + (DefFunction p ident mempty VUnitType value, unnormType) addFunctionDefFromResource :: (MonadReadResources m) => Provenance -> Identifier -> WHNFValue Builtin -> m () addFunctionDefFromResource p ident value = do + noteExplicitParameter ident value let decl = mkFunctionDefFromResource p ident value tell (Map.singleton ident decl) -type MonadReadResources m = - ( MonadIO m, - MonadExpandResources m, - MonadFreeContext Builtin m, - MonadWriter (FreeCtx Builtin) m - ) - -- | Goes through the program finding all -- the resources, comparing the data against the type in the spec, and making -- note of the values for implicit parameters. @@ -80,7 +72,8 @@ readResourcesInDecls = \case maybeDecl <- case decl of DefFunction {} -> return $ Just decl DefAbstract p ident defType declType -> do - gluedType <- Glued declType <$> normaliseInEmptyEnv declType + normalisedType <- normaliseInEmptyEnv declType + let gluedType = Glued declType normalisedType case defType of ParameterDef sort -> case sort of Inferable -> do @@ -100,7 +93,7 @@ readResourcesInDecls = \case networkLocations <- asks networks networkDetails <- checkNetwork networkLocations (ident, p) gluedType addNetworkType ident networkDetails - tell (Map.singleton ident decl) + tell (Map.singleton ident (DefAbstract p ident defType normalisedType, declType)) return Nothing PostulateDef -> return (Just decl) @@ -154,4 +147,4 @@ warnIfUnusedResources resourceType given found = do let unusedParams = givenNames `Set.difference` foundNames when (Set.size unusedParams > 0) $ logWarning $ - UnusedResource resourceType unusedParams + UnusedResources resourceType unusedParams diff --git a/vehicle/src/Vehicle/Compile/ExpandResources/Core.hs b/vehicle/src/Vehicle/Compile/ExpandResources/Core.hs index 3b45e337d..38db53b9a 100644 --- a/vehicle/src/Vehicle/Compile/ExpandResources/Core.hs +++ b/vehicle/src/Vehicle/Compile/ExpandResources/Core.hs @@ -2,17 +2,20 @@ module Vehicle.Compile.ExpandResources.Core where import Control.Monad.Reader import Control.Monad.State -import Data.Bifunctor (Bifunctor (..)) +import Control.Monad.Writer (MonadWriter) import Data.Map (Map) import Data.Map qualified as Map +import Vehicle.Compile.Context.Free (MonadFreeContext) import Vehicle.Compile.Error import Vehicle.Compile.Prelude -import Vehicle.Compile.Resource +import Vehicle.Data.NormalisedExpr +import Vehicle.Syntax.Builtin (Builtin) +import Vehicle.Verify.Core -------------------------------------------------------------------------------- -- Context -type NetworkContext = Map Name (FilePath, NetworkType) +type NetworkContext = Map Name NetworkContextInfo -------------------------------------------------------------------------------- -- Resource contexts @@ -21,19 +24,33 @@ type InferableParameterEntry = (DeclProvenance, ExternalResource, Int) type InferableParameterContext = Map Identifier (Either Provenance InferableParameterEntry) +type ExplicitParameterContext = Map Identifier (WHNFValue Builtin) + -------------------------------------------------------------------------------- -- The resource monad +type MonadReadResources m = + ( MonadIO m, + MonadExpandResources m, + MonadFreeContext Builtin m, + MonadWriter (FreeCtx Builtin) m + ) + type MonadExpandResources m = ( MonadCompile m, MonadReader Resources m, - MonadState (NetworkContext, InferableParameterContext) m + MonadState (NetworkContext, InferableParameterContext, ExplicitParameterContext) m ) +getExplicitParameterContext :: + (MonadExpandResources m) => + m ExplicitParameterContext +getExplicitParameterContext = gets (\(_, _, w) -> w) + getInferableParameterContext :: (MonadExpandResources m) => m InferableParameterContext -getInferableParameterContext = gets snd +getInferableParameterContext = gets (\(_, v, _) -> v) isInferableParameter :: (MonadExpandResources m) => @@ -48,7 +65,15 @@ noteInferableParameter :: Identifier -> m () noteInferableParameter p ident = - modify (second $ Map.insert ident (Left p)) + modify (\(u, v, w) -> (u, Map.insert ident (Left p) v, w)) + +noteExplicitParameter :: + (MonadExpandResources m) => + Identifier -> + WHNFValue Builtin -> + m () +noteExplicitParameter ident value = + modify (\(u, v, w) -> (u, v, Map.insert ident value w)) addPossibleInferableParameterSolution :: (MonadExpandResources m) => @@ -56,11 +81,12 @@ addPossibleInferableParameterSolution :: InferableParameterEntry -> m () addPossibleInferableParameterSolution ident entry = - modify (second $ Map.insert ident (Right entry)) + modify (\(u, v, w) -> (u, Map.insert ident (Right entry) v, w)) addNetworkType :: (MonadExpandResources m) => Identifier -> - (FilePath, NetworkType) -> + NetworkContextInfo -> m () -addNetworkType ident details = modify $ first $ Map.insert (nameOf ident) details +addNetworkType ident details = + modify (\(u, v, w) -> (Map.insert (nameOf ident) details u, v, w)) diff --git a/vehicle/src/Vehicle/Compile/ExpandResources/Dataset/IDX.hs b/vehicle/src/Vehicle/Compile/ExpandResources/Dataset/IDX.hs index 0200fecf8..779b74577 100644 --- a/vehicle/src/Vehicle/Compile/ExpandResources/Dataset/IDX.hs +++ b/vehicle/src/Vehicle/Compile/ExpandResources/Dataset/IDX.hs @@ -22,7 +22,7 @@ import Vehicle.Compile.ExpandResources.Core import Vehicle.Compile.Prelude import Vehicle.Compile.Print import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr -- | Reads the IDX dataset from the provided file, checking that the user type diff --git a/vehicle/src/Vehicle/Compile/ExpandResources/Network.hs b/vehicle/src/Vehicle/Compile/ExpandResources/Network.hs index e7fded2b2..8ec4f8234 100644 --- a/vehicle/src/Vehicle/Compile/ExpandResources/Network.hs +++ b/vehicle/src/Vehicle/Compile/ExpandResources/Network.hs @@ -11,31 +11,32 @@ import Vehicle.Compile.Prelude import Vehicle.Compile.Print import Vehicle.Compile.Resource import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr +import Vehicle.Verify.Core (NetworkContextInfo (..)) -------------------------------------------------------------------------------- -- Network typing checkNetwork :: forall m. - (MonadExpandResources m) => + (MonadReadResources m) => NetworkLocations -> DeclProvenance -> GluedType Builtin -> - m (FilePath, NetworkType) + m NetworkContextInfo checkNetwork networkLocations decl@(ident, _) networkType = do case Map.lookup (identifierName ident) networkLocations of Nothing -> throwError $ ResourceNotProvided decl Network Just location -> do typ <- getNetworkType decl networkType - return (location, typ) + return $ NetworkContextInfo location typ -- | Decomposes the Pi types in a network type signature, checking that the -- binders are explicit and their types are equal. getNetworkType :: forall m. - (MonadExpandResources m) => + (MonadReadResources m) => DeclProvenance -> GluedType Builtin -> m NetworkType @@ -70,17 +71,19 @@ getNetworkType decl networkType = case normalised networkType of return (elemType, []) getTensorDimension :: InputOrOutput -> WHNFType Builtin -> m Int - getTensorDimension io dim = - case dim of - VNatLiteral n -> return n - VFreeVar varIdent _ -> do - implicitParameters <- getInferableParameterContext - case Map.lookup varIdent implicitParameters of - Nothing -> throwError $ NetworkTypeHasVariableSizeTensor decl networkType dim io - Just Left {} -> throwError $ NetworkTypeHasImplicitSizeTensor decl networkType varIdent io - Just (Right (_, _, d)) -> return d - dims -> - throwError $ NetworkTypeHasVariableSizeTensor decl networkType dims io + getTensorDimension io dim = case dim of + VNatLiteral n -> return n + VFreeVar varIdent _ -> do + implicitParameters <- getInferableParameterContext + case Map.lookup varIdent implicitParameters of + Just Left {} -> throwError $ NetworkTypeHasImplicitSizeTensor decl networkType varIdent io + Just (Right (_, _, d)) -> return d + Nothing -> do + explicitParameters <- getExplicitParameterContext + case Map.lookup varIdent explicitParameters of + Nothing -> throwError $ NetworkTypeHasVariableSizeTensor decl networkType dim io + Just value -> getTensorDimension io value + _ -> throwError $ NetworkTypeHasVariableSizeTensor decl networkType dim io getElementType :: WHNFType Builtin -> m NetworkBaseType getElementType = \case diff --git a/vehicle/src/Vehicle/Compile/ExpandResources/Parameter.hs b/vehicle/src/Vehicle/Compile/ExpandResources/Parameter.hs index 4f037ace1..ccbef5d49 100644 --- a/vehicle/src/Vehicle/Compile/ExpandResources/Parameter.hs +++ b/vehicle/src/Vehicle/Compile/ExpandResources/Parameter.hs @@ -13,7 +13,7 @@ import Vehicle.Compile.ExpandResources.Core import Vehicle.Compile.Prelude import Vehicle.Compile.Print import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr -------------------------------------------------------------------------------- diff --git a/vehicle/src/Vehicle/Compile/Monomorphisation.hs b/vehicle/src/Vehicle/Compile/Monomorphisation.hs index 2cf19da57..ca3e3008c 100644 --- a/vehicle/src/Vehicle/Compile/Monomorphisation.hs +++ b/vehicle/src/Vehicle/Compile/Monomorphisation.hs @@ -37,6 +37,7 @@ import Vehicle.Compile.Print (prettyFriendly, prettyFriendlyEmptyCtx, prettyVerb import Vehicle.Compile.Type.Subsystem.Standard () import Vehicle.Compile.Type.Subsystem.Standard.Core import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Data.DeBruijn import Vehicle.Data.Hashing () import Vehicle.Libraries.StandardLibrary.Definitions diff --git a/vehicle/src/Vehicle/Compile/Normalise/Builtin.hs b/vehicle/src/Vehicle/Compile/Normalise/Builtin.hs index db9cead30..72aa081e5 100644 --- a/vehicle/src/Vehicle/Compile/Normalise/Builtin.hs +++ b/vehicle/src/Vehicle/Compile/Normalise/Builtin.hs @@ -14,7 +14,9 @@ import Data.Foldable (foldrM) import Data.Maybe (fromMaybe, mapMaybe) import Vehicle.Compile.Error import Vehicle.Compile.Prelude +import Vehicle.Compile.Print (prettyVerbose) import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr import Vehicle.Syntax.Builtin @@ -137,13 +139,23 @@ evalBuiltinFunction evalApp b args = case b of type BlockingArgs = [Int] traverseBuiltinBlockingArgs :: + (MonadCompile m, PrintableBuiltin builtin, HasStandardData builtin) => + (WHNFValue builtin -> m (WHNFValue builtin)) -> + builtin -> + WHNFSpine builtin -> + m (WHNFSpine builtin) +traverseBuiltinBlockingArgs f b args = case getBuiltinFunction b of + Just func -> traverseBuiltinFunctionBlockingArgs f func args + Nothing -> return args + +traverseBuiltinFunctionBlockingArgs :: (MonadCompile m, PrintableBuiltin builtin, HasStandardData builtin) => (WHNFValue builtin -> m (WHNFValue builtin)) -> BuiltinFunction -> WHNFSpine builtin -> m (WHNFSpine builtin) -traverseBuiltinBlockingArgs f b args = - traverseBlockingArgs f args $ case b of +traverseBuiltinFunctionBlockingArgs f b args = + traverseBlockingArgs f b args $ case b of Quantifier {} -> [] Optimise {} -> [] Not -> [0] @@ -173,12 +185,13 @@ traverseBuiltinBlockingArgs f b args = traverseBlockingArgs :: forall m builtin. - (MonadCompile m) => + (MonadCompile m, PrintableBuiltin builtin) => (WHNFValue builtin -> m (WHNFValue builtin)) -> + BuiltinFunction -> WHNFSpine builtin -> BlockingArgs -> m (WHNFSpine builtin) -traverseBlockingArgs f = go 0 +traverseBlockingArgs f b originalSpine originalBlockingArgs = go 0 originalSpine originalBlockingArgs where go :: Int -> @@ -187,11 +200,17 @@ traverseBlockingArgs f = go 0 m (WHNFSpine builtin) go _ spine [] = return spine go _ [] _ = - compilerDeveloperError "run out of args when traversing blocked arguments in spine" + compilerDeveloperError $ + "run out of args when traversing blocked arguments" + <+> pretty originalBlockingArgs + <+> "in spine" + <+> prettyVerbose originalSpine + <+> "for" + <+> quotePretty b go argNo (arg : args) (blockedArg : blockedArgs) | isRuntimeRelevant arg && argNo == blockedArg = (:) <$> traverse f arg <*> go (argNo + 1) args blockedArgs - | isRuntimeRelevant arg = (:) <$> (return arg) <*> go (argNo + 1) args (blockedArg : blockedArgs) - | otherwise = (:) <$> (return arg) <*> go argNo args (blockedArg : blockedArgs) + | isRuntimeRelevant arg = (arg :) <$> go (argNo + 1) args (blockedArg : blockedArgs) + | otherwise = (arg :) <$> go argNo args (blockedArg : blockedArgs) ----------------------------------------------------------------------------- -- Individual builtin evaluation diff --git a/vehicle/src/Vehicle/Compile/Normalise/NBE.hs b/vehicle/src/Vehicle/Compile/Normalise/NBE.hs index a2e6e1fe9..40e83ceda 100644 --- a/vehicle/src/Vehicle/Compile/Normalise/NBE.hs +++ b/vehicle/src/Vehicle/Compile/Normalise/NBE.hs @@ -3,38 +3,35 @@ {-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} module Vehicle.Compile.Normalise.NBE - ( AbstractFreeVarInterpretation, - noAbstractFreeVarInterpretation, - MonadNorm, + ( MonadNorm, normalise, normaliseInEnv, normaliseInEmptyEnv, normaliseApp, - renormalise, eval, - lookupIdentValueInEnv, findInstanceArg, + evalBuiltin, ) where import Data.Data (Proxy (..)) import Data.List.NonEmpty as NonEmpty (toList) +import Vehicle.Compile.Context.Bound.Class (MonadBoundContext (..)) import Vehicle.Compile.Context.Free.Class (MonadFreeContext, getDecl) -import Vehicle.Compile.Context.Var (MonadVarContext, getBoundCtx) import Vehicle.Compile.Error -import Vehicle.Compile.Normalise.Builtin (evalBuiltin) +import Vehicle.Compile.Normalise.Builtin qualified as Builtin (evalBuiltin) import Vehicle.Compile.Prelude import Vehicle.Compile.Print import Vehicle.Data.BuiltinInterface import Vehicle.Data.NormalisedExpr --- NOTE: there is no evaluate to NF in this file. To do it +-- NOTE: there is no evaluatation to NF in this file. To do it -- efficiently you should just evaluate to WHNF and then recursively -- evaluate as required. normalise :: forall builtin m. - (MonadVarContext builtin m) => + (MonadBoundContext builtin m, MonadFreeContext builtin m) => Expr Ix builtin -> m (WHNFValue builtin) normalise e = do @@ -43,12 +40,11 @@ normalise e = do normaliseInEnv env e normaliseInEnv :: - forall builtin m. (MonadFreeContext builtin m) => - WHNFEnv builtin -> + WHNFBoundEnv builtin -> Expr Ix builtin -> m (WHNFValue builtin) -normaliseInEnv = eval (\ident args -> return $ VFreeVar ident args) +normaliseInEnv = eval normaliseInEmptyEnv :: (MonadFreeContext builtin m) => @@ -57,97 +53,75 @@ normaliseInEmptyEnv :: normaliseInEmptyEnv = normaliseInEnv mempty normaliseApp :: - (MonadNorm builtin m) => - WHNFValue builtin -> - WHNFSpine builtin -> - m (WHNFValue builtin) -normaliseApp = evalApp noAbstractFreeVarInterpretation - -renormalise :: - (MonadNorm builtin m) => - WHNFEnv builtin -> + (MonadFreeContext builtin m) => WHNFValue builtin -> - m (WHNFValue builtin) -renormalise = reeval noAbstractFreeVarInterpretation - ------------------------------------------------------------------------------ --- Options during NBE - -type AbstractFreeVarInterpretation builtin m = - (MonadNorm builtin m) => - Identifier -> WHNFSpine builtin -> m (WHNFValue builtin) - -noAbstractFreeVarInterpretation :: AbstractFreeVarInterpretation builtin m -noAbstractFreeVarInterpretation ident args = return $ VFreeVar ident args +normaliseApp = evalApp ----------------------------------------------------------------------------- -- Evaluation type MonadNorm builtin m = - ( MonadFreeContext builtin m + ( PrintableBuiltin builtin, + HasStandardData builtin, + MonadFreeContext builtin m ) eval :: (MonadNorm builtin m) => - AbstractFreeVarInterpretation builtin m -> - WHNFEnv builtin -> + WHNFBoundEnv builtin -> Expr Ix builtin -> m (WHNFValue builtin) -eval interp env expr = do +eval env expr = do showEntry env expr result <- case expr of Hole {} -> resolutionError currentPass "Hole" Meta _ m -> return $ VMeta m [] Universe _ u -> return $ VUniverse u Builtin _ b -> return $ VBuiltin b [] + BoundVar _ v -> lookupIxValueInEnv env v + FreeVar _ v -> lookupIdentValueInEnv v Lam _ binder body -> do - binder' <- evalBinder interp env binder + binder' <- evalBinder env binder return $ VLam binder' (WHNFBody env body) Pi _ binder body -> do - binder' <- evalBinder interp env binder + binder' <- evalBinder env binder let newEnv = extendEnvWithBound binder' env - body' <- eval interp newEnv body + body' <- eval newEnv body return $ VPi binder' body' - BoundVar _ i -> - lookupIxValueInEnv i env - FreeVar _ ident -> - lookupIdentValueInEnv interp env ident Let _ bound binder body -> do - binder' <- evalBinder interp env binder - boundNormExpr <- eval interp env bound + binder' <- evalBinder env binder + boundNormExpr <- eval env bound let newEnv = extendEnvWithDefined boundNormExpr binder' env - eval interp newEnv body + eval newEnv body App _ fun args -> do - fun' <- eval interp env fun - args' <- traverse (traverse (eval interp env)) (NonEmpty.toList args) - evalApp interp fun' args' + fun' <- eval env fun + args' <- traverse (traverse (eval env)) (NonEmpty.toList args) + evalApp fun' args' showExit env result return result evalBinder :: (MonadNorm builtin m) => - AbstractFreeVarInterpretation builtin m -> - WHNFEnv builtin -> + WHNFBoundEnv builtin -> Binder Ix builtin -> m (WHNFBinder builtin) -evalBinder interp env = traverse (eval interp env) +evalBinder env = traverse (eval env) evalApp :: (MonadNorm builtin m) => - AbstractFreeVarInterpretation builtin m -> WHNFValue builtin -> WHNFSpine builtin -> m (WHNFValue builtin) -evalApp _interp fun [] = return fun -evalApp interp fun args@(a : as) = do +evalApp fun [] = return fun +evalApp fun args@(a : as) = do showApp fun args result <- case fun of VMeta v spine -> return $ VMeta v (spine <> args) VBoundVar v spine -> return $ VBoundVar v (spine <> args) - VFreeVar v spine -> interp v (spine <> args) + VFreeVar v spine -> return $ VFreeVar v (spine <> args) VLam binder (WHNFBody env body) | not (visibilityMatches binder a) -> do compilerDeveloperError $ @@ -163,147 +137,77 @@ evalApp interp fun args@(a : as) = do ) | otherwise -> do let newEnv = extendEnvWithDefined (argExpr a) binder env - body' <- eval interp newEnv body + body' <- eval newEnv body case as of [] -> return body' - (b : bs) -> evalApp interp body' (b : bs) + (b : bs) -> evalApp body' (b : bs) VBuiltin b spine | not (isTypeClassOp b) -> do - evalBuiltin (evalApp interp) b (spine <> args) + evalBuiltin b (spine <> args) | otherwise -> do (inst, remainingArgs) <- findInstanceArg b args - evalApp interp inst remainingArgs + evalApp inst remainingArgs VUniverse {} -> unexpectedExprError currentPass ("VUniverse" <+> prettyVerbose args) VPi {} -> unexpectedExprError currentPass ("VPi" <+> prettyVerbose args) showAppExit result return result +evalBuiltin :: + (MonadNorm builtin m) => + builtin -> + WHNFSpine builtin -> + m (WHNFValue builtin) +evalBuiltin = Builtin.evalBuiltin evalApp + lookupIdentValueInEnv :: forall builtin m. (MonadNorm builtin m) => - AbstractFreeVarInterpretation builtin m -> - WHNFEnv builtin -> Identifier -> m (WHNFValue builtin) -lookupIdentValueInEnv interp env ident = do +lookupIdentValueInEnv ident = do decl <- getDecl (Proxy @builtin) currentPass ident - case bodyOf decl of - Just expr -> eval interp env expr - _ -> return $ VFreeVar ident [] + return $ case bodyOf decl of + Just value -> value + _ -> VFreeVar ident [] lookupIxValueInEnv :: (MonadNorm builtin m) => + WHNFBoundEnv builtin -> Ix -> - WHNFEnv builtin -> m (WHNFValue builtin) -lookupIxValueInEnv ix env = do - (_binder, value) <- lookupIxInBoundCtx currentPass ix env +lookupIxValueInEnv boundEnv ix = do + (_binder, value) <- lookupIxInBoundCtx currentPass ix boundEnv case value of Defined v -> return v Bound -> do -- We need to calculate the level in the final scope. Note this -- step could probably be optimised by storing the required level -- on the `Bound` contructor. - let inScopeEnv = drop (unIx ix) env + let inScopeEnv = drop (unIx ix) boundEnv let lv = Lv $ length (filter isBoundEntry inScopeEnv) - 1 return $ VBoundVar lv [] ------------------------------------------------------------------------------ --- Reevaluation - -reeval :: - (MonadNorm builtin m) => - AbstractFreeVarInterpretation builtin m -> - WHNFEnv builtin -> - WHNFValue builtin -> - m (WHNFValue builtin) -reeval interp env expr = do - showNormEntry env expr - result <- case expr of - VUniverse {} -> return expr - VLam binder (WHNFBody lamEnv body) -> do - lamEnv' <- traverse (reevalEnvEntry interp env) lamEnv - return $ VLam binder (WHNFBody lamEnv' body) - VPi {} -> return expr - VMeta m spine -> VMeta m <$> reevalSpine interp env spine - VFreeVar v spine -> do - value <- lookupIdentValueInEnv interp env v - spine' <- reevalSpine interp env spine - evalApp interp value spine' - VBoundVar v spine -> do - value <- lookupLvValueInEnv v env - spine' <- reevalSpine interp env spine - evalApp interp value spine' - VBuiltin b spine -> - evalBuiltin (evalApp interp) b =<< reevalSpine interp env spine - showNormExit env result - return result - -reevalEnvEntry :: - (MonadNorm builtin m) => - AbstractFreeVarInterpretation builtin m -> - WHNFEnv builtin -> - EnvEntry 'WHNF builtin -> - m (EnvEntry 'WHNF builtin) -reevalEnvEntry interp env (binder, value) = - (binder,) <$> case value of - Bound -> return Bound - Defined v -> Defined <$> reeval interp env v - -reevalSpine :: - (MonadNorm builtin m) => - AbstractFreeVarInterpretation builtin m -> - WHNFEnv builtin -> - WHNFSpine builtin -> - m (WHNFSpine builtin) -reevalSpine interp env = traverse (traverse (reeval interp env)) - -lookupLvValueInEnv :: - (MonadNorm builtin m) => - Lv -> - WHNFEnv builtin -> - m (WHNFValue builtin) -lookupLvValueInEnv l env = do - (_binder, value) <- lookupLvInBoundCtx currentPass l env - case value of - Defined v -> return v - Bound -> return $ VBoundVar l [] - ----------------------------------------------------------------------------- -- Other currentPass :: Doc () currentPass = "normalisation by evaluation" -showEntry :: (MonadNorm builtin m) => WHNFEnv builtin -> Expr Ix builtin -> m () +showEntry :: (MonadNorm builtin m) => WHNFBoundEnv builtin -> Expr Ix builtin -> m () showEntry _env _expr = do -- logDebug MidDetail $ "nbe-entry" <+> prettyVerbose expr <+> " { env=" <+> prettyVerbose env <+> "}" -- logDebug MidDetail $ "nbe-entry" <+> prettyFriendly (WithContext expr (fmap fst env)) <+> " { env=" <+> hang 0 (prettyVerbose env) <+> "}" -- incrCallDepth return () -showExit :: (MonadNorm builtin m) => WHNFEnv builtin -> WHNFValue builtin -> m () +showExit :: (MonadNorm builtin m) => WHNFBoundEnv builtin -> WHNFValue builtin -> m () showExit _env _result = do -- decrCallDepth -- logDebug MidDetail $ "nbe-exit" <+> prettyVerbose result -- logDebug MidDetail $ "nbe-exit" <+> prettyFriendly (WithContext result (fmap fst env)) return () -showNormEntry :: (MonadNorm builtin m) => WHNFEnv builtin -> WHNFValue builtin -> m () -showNormEntry _env _expr = do - -- logDebug MidDetail $ "reeval-entry" <+> prettyVerbose expr -- <+> " { env=" <+> prettyVerbose env <+> "}" - -- logDebug MidDetail $ "reeval-entry" <+> prettyFriendly (WithContext expr (fmap fst env)) -- <+> " { env=" <+> hang 0 (prettyVerbose env) <+> "}" - -- incrCallDepth - return () - -showNormExit :: (MonadNorm builtin m) => WHNFEnv builtin -> WHNFValue builtin -> m () -showNormExit _env _result = do - -- decrCallDepth - -- logDebug MidDetail $ "reeval-exit" <+> prettyVerbose result - -- logDebug MidDetail $ "reeval-exit" <+> prettyFriendly (WithContext result (fmap fst env)) - return () - showApp :: (MonadNorm builtin m) => WHNFValue builtin -> WHNFSpine builtin -> m () showApp _fun _spine = do -- logDebug MaxDetail $ "nbe-app:" <+> prettyVerbose fun <+> "@" <+> prettyVerbose spine diff --git a/vehicle/src/Vehicle/Compile/Normalise/Quote.hs b/vehicle/src/Vehicle/Compile/Normalise/Quote.hs index f34523882..b29673a66 100644 --- a/vehicle/src/Vehicle/Compile/Normalise/Quote.hs +++ b/vehicle/src/Vehicle/Compile/Normalise/Quote.hs @@ -56,7 +56,7 @@ instance Quote (VArg strategy builtin) (Arg Ix builtin) where quoteApp :: Lv -> Provenance -> Expr Ix builtin -> Spine strategy builtin -> Expr Ix builtin quoteApp l p fn spine = normAppList p fn (fmap (quote p l) spine) -envSubst :: Provenance -> Lv -> WHNFEnv builtin -> Substitution (Expr Ix builtin) +envSubst :: Provenance -> Lv -> WHNFBoundEnv builtin -> Substitution (Expr Ix builtin) envSubst p level env i = case lookupIx env i of Nothing -> developerError $ diff --git a/vehicle/src/Vehicle/Compile/Print.hs b/vehicle/src/Vehicle/Compile/Print.hs index 080591104..b62efe5d9 100644 --- a/vehicle/src/Vehicle/Compile/Print.hs +++ b/vehicle/src/Vehicle/Compile/Print.hs @@ -134,7 +134,7 @@ type family StrategyFor (tags :: Tags) a :: Strategy where StrategyFor ('Unnamed tags) (WHNFValue builtin) = 'DescopeNaively (StrategyFor tags (Expr Name builtin)) StrategyFor ('Unnamed tags) (WHNFArg builtin) = 'DescopeNaively (StrategyFor tags (Arg Name builtin)) StrategyFor ('Unnamed tags) (WHNFBinder builtin) = 'DescopeNaively (StrategyFor tags (Binder Name builtin)) - StrategyFor tags (EnvValue 'WHNF builtin) = StrategyFor tags (WHNFValue builtin) + StrategyFor tags (BoundEnvValue 'WHNF builtin) = StrategyFor tags (WHNFValue builtin) StrategyFor tags (GenericBinder ()) = 'Pretty -- To standardise builtins StrategyFor ('StandardiseBuiltin tags) (Prog Name builtin) = 'ConvertBuiltins (StrategyFor tags (Prog Name Builtin)) @@ -179,7 +179,6 @@ type family StrategyFor (tags :: Tags) a :: Strategy where StrategyFor tags (IntMap a) = 'Opaque (StrategyFor tags a) StrategyFor tags [a] = 'Opaque (StrategyFor tags a) StrategyFor tags (Maybe a) = 'Opaque (StrategyFor tags a) - StrategyFor tags (BooleanExpr a) = 'Opaque (StrategyFor tags a) StrategyFor tags (ConjunctAll a) = 'Opaque (StrategyFor tags a) StrategyFor tags (DisjunctAll a) = 'Opaque (StrategyFor tags a) StrategyFor tags (MaybeTrivial a) = 'Opaque (StrategyFor tags a) @@ -187,8 +186,6 @@ type family StrategyFor (tags :: Tags) a :: Strategy where 'MapTuple2 (StrategyFor tags (Contextualised a ctx)) (StrategyFor tags (Contextualised b ctx)) StrategyFor tags (Contextualised [a] ctx) = StrategyFor tags [Contextualised a ctx] - StrategyFor tags (Contextualised (BooleanExpr a) ctx) = - StrategyFor tags (BooleanExpr (Contextualised a ctx)) StrategyFor tags (Contextualised (Maybe a) ctx) = StrategyFor tags (Maybe (Contextualised a ctx)) StrategyFor tags (Contextualised (ConjunctAll a) ctx) = @@ -444,7 +441,7 @@ instance (PrettyUsing rest (Expr Ix builtin)) => PrettyUsing ('Denormalise rest) instance (PrettyUsing rest (Arg Ix builtin)) => PrettyUsing ('Denormalise rest) (WHNFArg builtin) where prettyUsing e = prettyUsing @rest (unnormalise @(WHNFArg builtin) @(Arg Ix builtin) 0 e) -instance (PrettyUsing rest (WHNFValue builtin)) => PrettyUsing rest (EnvValue 'WHNF builtin) where +instance (PrettyUsing rest (WHNFValue builtin)) => PrettyUsing rest (BoundEnvValue 'WHNF builtin) where prettyUsing = \case Bound {} -> "" Defined v -> prettyUsing @rest v @@ -533,12 +530,6 @@ instance (PrettyUsing rest a) => PrettyUsing ('Opaque rest) (MaybeTrivial a) whe Trivial False -> "False" NonTrivial x -> prettyUsing @rest x -instance (PrettyUsing rest a) => PrettyUsing ('Opaque rest) (BooleanExpr a) where - prettyUsing = \case - Query x -> prettyUsing @rest x - Disjunct x y -> prettyUsing @('Opaque rest) x <+> "or" <+> prettyUsing @('Opaque rest) y - Conjunct x y -> prettyUsing @('Opaque rest) x <+> "and" <+> prettyUsing @('Opaque rest) y - instance (Functor f, PrettyUsing ('Opaque rest) (f (Contextualised a ctx))) => PrettyUsing ('Opaque rest) (Contextualised (f a) ctx) diff --git a/vehicle/src/Vehicle/Compile/Print/Warning.hs b/vehicle/src/Vehicle/Compile/Print/Warning.hs index 10364fdae..6572ca4fc 100644 --- a/vehicle/src/Vehicle/Compile/Print/Warning.hs +++ b/vehicle/src/Vehicle/Compile/Print/Warning.hs @@ -2,45 +2,61 @@ module Vehicle.Compile.Print.Warning where +import Data.List (sortOn) +import Data.List.NonEmpty (NonEmpty, sort) import Data.Set qualified as Set import Vehicle.Backend.Prelude (Target (..)) -import Vehicle.Backend.Queries.Variable import Vehicle.Prelude import Vehicle.Prelude.Warning -import Vehicle.Syntax.AST import Vehicle.Verify.Core +import Vehicle.Verify.Variable -instance Pretty CompileWarning where +instance Pretty SummarisedCompileWarning where pretty = \case - UnusedResource resourceType unusedResources -> + UnusedResourcesSummary resourceType unusedResources -> "the following" <+> pretty resourceType <> "s were provided" <+> "but not used by the specification:" <+> prettySet unusedResources - ResortingtoFMElimination propertyName unsolvedVars -> do + TrivialPropertySummary propertyName status -> + "The property" + <+> quotePretty propertyName + <+> "was found to evaluate to" + <+> quotePretty status + <+> "without needing to call the verifier. This usually indicates a fault with either the" + <+> "specification or any external datasets used." + UnnecessaryResourcesProvidedSummary target resources -> + "The following provided resources:" + <> line + <> line + <> indent 2 resourceDocs + <> line + <> line + <> "will be ignored as when compiling to" <+> pretty target <+> reasonUnnecessary + where + resourceDocs = vsep (fmap (\(r, n) -> pretty r <+> pretty n) resources) + reasonUnnecessary = case target of + ITP {} -> "their values will be taken directly from the verification cache." + ExplicitVehicle -> "their values should be provided upon export." + LossFunction {} -> "their values should be provided upon export." + VerifierQueries {} -> developerError "resources are necessary when compiling to verifier queries" + UnderSpecifiedProblemSpaceVariablesSummary propertyAddress unsolvedVars -> do let varsDoc = concatWith (\u v -> u <> "," <+> v) (fmap quotePretty (Set.toList unsolvedVars)) let pluralisedVarsDoc | length unsolvedVars == 1 = "variable" <+> varsDoc <+> "is" | otherwise = "variables" <+> varsDoc <+> "are" "In property" - <+> quotePretty (nameOf propertyName) + <+> quotePretty propertyAddress <+> "the quantified" <+> pluralisedVarsDoc <+> "not always directly related to the input or output of a network." <+> "This is frequently indicative of a bug in the specification." - TrivialProperty propertyName status -> - "The property" - <+> quotePretty propertyName - <+> "was found to evalute to" - <+> quotePretty status - <+> "without needing to call the verifier. This usually indicates a fault with either the" - <+> "specification or any external datasets used." - UnsoundStrictOrderConversion propertyName queryFormatID -> - "While compiling property" - <+> quotePretty propertyName - <> ", at least one of the generated SAT problems was found" + UnsoundStrictOrderConversionsSummary queryFormatID propertyAddress _ -> + "In property" + <+> quotePretty propertyAddress + <> ", at least one of the generated queries were found" <+> "to contain a strict inequality (i.e. constraints of the form 'x < y')." <+> "Unfortunately the" <+> pretty queryFormatID @@ -56,48 +72,43 @@ instance Pretty CompileWarning where <> line <> line <> "See https://github.com/vehicle-lang/vehicle/issues/74 for further details." - AllConstantInputsMarabouBug propertyName -> - "While compiling property" - <+> quotePretty propertyName - <> ", in at least one of the generated SAT problems" + AllConstantNetworkInputVariablesSummary _ propertyAddress queryIDs -> + "In property" + <+> quotePretty propertyAddress + <> ", in" + <+> prettyQueryIDs queryIDs <+> "all network inputs were fixed to be constants." <+> "Unfortunately there is a known bug in Marabou that it sometimes erroneously returns" - <+> "'unsat' for these type of degenerate problems." + <+> "'unsat' for these type of queries." <> line <> line <> "See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details." - UnderSpecifiedNetworkInputs propertyName queryFormat underSpecified -> - "While compiling property" - <+> quotePretty propertyName - <> ", in at least one of the generated SAT problems not all network input variables have both" + UnboundedNetworkInputVariablesSummary queryFormat propertyAddress varsByQueryID -> + "In property" + <+> quotePretty propertyAddress + <> ", the following network input variables do not always have both" <+> "a lower and a upper bound." - <+> "Such queries are not currently supported by the" + <+> "This is not currently supported by the" <+> pretty queryFormat <> "." <> line - <> line - <> "In particular, the following input variables are under-specified:" - <> line - <> indent 2 (vsep $ fmap prettyEntry underSpecified) + <> indent 2 (vsep $ fmap prettyQueries (sortOn (\(qs, _) -> sort qs) varsByQueryID)) where - prettyEntry :: (NetworkVariable, UnderConstrainedVariableStatus) -> Doc a - prettyEntry (var, constraint) = + prettyQueries :: (NonEmpty QueryID, [(NetworkRationalVariable, UnderConstrainedVariableStatus)]) -> Doc a + prettyQueries (queryIDs, vars) = + "In" <+> prettyQueryIDs queryIDs + <> ":" + <> line + <> indent 2 (vsep $ fmap prettyVar vars) + + prettyVar :: (NetworkRationalVariable, UnderConstrainedVariableStatus) -> Doc a + prettyVar (var, constraint) = pretty var <+> "-" <+> case constraint of - Unconstrained -> "no constraints" - BoundedAbove -> "bounded above but not below" - BoundedBelow -> "bounded below but not above" - ResourcesUnnecessariyProvidedForBackend target resources -> - "The following provided resources:" - <> line - <> line - <> indent 2 resourceDocs - <> line - <> line - <> "will be ignored as when compiling to" <+> pretty target <+> reasonUnnecessary - where - resourceDocs = vsep (fmap (\(r, n) -> pretty r <+> pretty n) resources) - reasonUnnecessary = case target of - ITP {} -> "their values will be taken directly from the verification cache." - ExplicitVehicle -> "their values should be provided upon export." - LossFunction {} -> "their values should be provided upon export." - VerifierQueries {} -> developerError "resources are necessary when compiling to verifier queries" + Unconstrained -> "no lower or upper bound" + BoundedAbove -> "no lower bound" + BoundedBelow -> "no upper bound" + +prettyQueryIDs :: NonEmpty QueryID -> Doc a +prettyQueryIDs ids = + (if length ids == 1 then "query" else "queries") + <+> prettyNonEmptyList (fmap pretty (sort ids)) diff --git a/vehicle/src/Vehicle/Compile/Resource.hs b/vehicle/src/Vehicle/Compile/Resource.hs index 765b7c764..40f6c522a 100644 --- a/vehicle/src/Vehicle/Compile/Resource.hs +++ b/vehicle/src/Vehicle/Compile/Resource.hs @@ -14,7 +14,7 @@ data NetworkType = NetworkType { inputTensor :: NetworkTensorType, outputTensor :: NetworkTensorType } - deriving (Show, Generic) + deriving (Eq, Ord, Show, Generic) instance ToJSON NetworkType @@ -31,7 +31,7 @@ data NetworkTensorType = NetworkTensorType { baseType :: NetworkBaseType, dimensions :: TensorDimensions } - deriving (Show, Generic) + deriving (Eq, Ord, Show, Generic) instance ToJSON NetworkTensorType @@ -48,7 +48,7 @@ instance Pretty NetworkTensorType where data NetworkBaseType = NetworkRatType - deriving (Enum, Show, Generic) + deriving (Eq, Ord, Enum, Show, Generic) instance ToJSON NetworkBaseType diff --git a/vehicle/src/Vehicle/Compile/Type.hs b/vehicle/src/Vehicle/Compile/Type.hs index e34bed001..92096612d 100644 --- a/vehicle/src/Vehicle/Compile/Type.hs +++ b/vehicle/src/Vehicle/Compile/Type.hs @@ -10,7 +10,7 @@ import Control.Monad.Except (MonadError (..)) import Data.List (partition) import Data.List.NonEmpty (NonEmpty (..)) import Data.Proxy (Proxy (..)) -import Vehicle.Compile.Context.Free.Class +import Vehicle.Compile.Context.Free import Vehicle.Compile.Error import Vehicle.Compile.Prelude import Vehicle.Compile.Print @@ -108,7 +108,7 @@ typeCheckAbstractDef p ident defSort uncheckedType = do -- solve constraints beforehand in order to allow for normalisation, -- but really only need to have solved type-class constraints. logDebug MaxDetail $ prettyVerbose substCheckedType - gluedType <- glueNBE emptyEnv substCheckedType + gluedType <- glueNBE emptyBoundEnv substCheckedType updatedCheckedType <- restrictAbstractDefType defSort (ident, p) gluedType let updatedCheckedDecl = DefAbstract p ident defSort updatedCheckedType @@ -146,7 +146,7 @@ typeCheckFunction p ident anns typ body = do if isProperty anns then do - gluedDeclType <- glueNBE emptyEnv (typeOf substDecl) + gluedDeclType <- glueNBE emptyBoundEnv (typeOf substDecl) restrictPropertyType (ident, p) gluedDeclType solveConstraints (Just substDecl) substAgainDecl <- substMetas substDecl diff --git a/vehicle/src/Vehicle/Compile/Type/Constraint/IndexSolver.hs b/vehicle/src/Vehicle/Compile/Type/Constraint/IndexSolver.hs index fb7905012..c5314f914 100644 --- a/vehicle/src/Vehicle/Compile/Type/Constraint/IndexSolver.hs +++ b/vehicle/src/Vehicle/Compile/Type/Constraint/IndexSolver.hs @@ -11,6 +11,8 @@ import Vehicle.Compile.Type.Meta (MetaSet) import Vehicle.Compile.Type.Meta.Set qualified as MetaSet import Vehicle.Compile.Type.Monad import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr solveIndexConstraint :: diff --git a/vehicle/src/Vehicle/Compile/Type/Force.hs b/vehicle/src/Vehicle/Compile/Type/Force.hs index bc7c17972..74d570a80 100644 --- a/vehicle/src/Vehicle/Compile/Type/Force.hs +++ b/vehicle/src/Vehicle/Compile/Type/Force.hs @@ -5,7 +5,6 @@ module Vehicle.Compile.Type.Force where import Data.Maybe (fromMaybe, isJust) import Vehicle.Compile.Context.Free -import Vehicle.Compile.Normalise.Builtin import Vehicle.Compile.Normalise.NBE import Vehicle.Compile.Prelude import Vehicle.Compile.Print (prettyFriendly) @@ -33,7 +32,11 @@ forceHead subst ctx expr = do Nothing -> return expr Just forcedExpr -> do let dbCtx = boundContextOf ctx - logDebug MaxDetail $ "forced" <+> prettyFriendly (WithContext expr dbCtx) <+> "to" <+> prettyFriendly (WithContext forcedExpr dbCtx) + logDebug MaxDetail $ + "forced" + <+> prettyFriendly (WithContext expr dbCtx) + <+> "to" + <+> prettyFriendly (WithContext forcedExpr dbCtx) return forcedExpr return (forcedExpr, blockingMetas) @@ -90,6 +93,5 @@ forceBuiltin subst b spine = case getBuiltinFunction b of result <- if not anyArgsReduced then return Nothing - else do - Just <$> evalBuiltin normaliseApp b argResults + else Just <$> evalBuiltin b argResults return (result, blockingMetas) diff --git a/vehicle/src/Vehicle/Compile/Type/Irrelevance.hs b/vehicle/src/Vehicle/Compile/Type/Irrelevance.hs index e4db1bb83..6a90f16e6 100644 --- a/vehicle/src/Vehicle/Compile/Type/Irrelevance.hs +++ b/vehicle/src/Vehicle/Compile/Type/Irrelevance.hs @@ -11,6 +11,7 @@ import Vehicle.Compile.Error (MonadCompile) import Vehicle.Compile.Prelude import Vehicle.Compile.Print (prettyFriendly) import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Data.DeBruijn -- | Removes all irrelevant code from the program/expression. diff --git a/vehicle/src/Vehicle/Compile/Type/Meta/Substitution.hs b/vehicle/src/Vehicle/Compile/Type/Meta/Substitution.hs index a81c5704e..d43359a08 100644 --- a/vehicle/src/Vehicle/Compile/Type/Meta/Substitution.hs +++ b/vehicle/src/Vehicle/Compile/Type/Meta/Substitution.hs @@ -7,7 +7,6 @@ where import Data.List.NonEmpty (NonEmpty) import Vehicle.Compile.Context.Free import Vehicle.Compile.Error -import Vehicle.Compile.Normalise.Builtin (evalBuiltin) import Vehicle.Compile.Normalise.NBE import Vehicle.Compile.Prelude import Vehicle.Compile.Type.Core @@ -92,7 +91,7 @@ instance MetaSubstitutable m builtin (WHNFValue builtin) where VBoundVar v spine -> VBoundVar v <$> traverse (subst s) spine VBuiltin b spine -> do spine' <- traverse (subst s) spine - evalBuiltin normaliseApp b spine' + evalBuiltin b spine' -- NOTE: no need to lift the substitutions here as we're passing under the binders -- because by construction every meta-variable solution is a closed term. @@ -108,7 +107,7 @@ instance MetaSubstitutable m builtin (Env 'WHNF builtin) where newEnvEntries <- subst s envEntries return $ Env { envEntries = newEnvEntries, .. } -} -instance MetaSubstitutable m builtin (EnvValue 'WHNF builtin) where +instance MetaSubstitutable m builtin (BoundEnvValue 'WHNF builtin) where subst s = \case Bound -> return Bound Defined value -> Defined <$> subst s value diff --git a/vehicle/src/Vehicle/Compile/Type/Monad/Class.hs b/vehicle/src/Vehicle/Compile/Type/Monad/Class.hs index b62d419e0..7b4b1ad8b 100644 --- a/vehicle/src/Vehicle/Compile/Type/Monad/Class.hs +++ b/vehicle/src/Vehicle/Compile/Type/Monad/Class.hs @@ -528,5 +528,5 @@ copyContext (ConstraintContext _cid originProv creationProv _blockingStatus ctx) -- Constraints -------------------------------------------------------------------------------- -glueNBE :: (MonadFreeContext builtin m) => WHNFEnv builtin -> Expr Ix builtin -> m (GluedExpr builtin) +glueNBE :: (MonadFreeContext builtin m) => WHNFBoundEnv builtin -> Expr Ix builtin -> m (GluedExpr builtin) glueNBE env e = Glued e <$> normaliseInEnv env e diff --git a/vehicle/src/Vehicle/Compile/Type/Monad/Instance.hs b/vehicle/src/Vehicle/Compile/Type/Monad/Instance.hs index b16dfbe6a..2330bf92f 100644 --- a/vehicle/src/Vehicle/Compile/Type/Monad/Instance.hs +++ b/vehicle/src/Vehicle/Compile/Type/Monad/Instance.hs @@ -74,7 +74,7 @@ mapTypeCheckerT f m = TypeCheckerT (mapFreeContextT (mapReaderT (mapStateT f)) ( -- Instances that TypeCheckerT satisfies instance (PrintableBuiltin builtin, HasStandardData builtin, MonadCompile m) => MonadFreeContext builtin (TypeCheckerT builtin m) where - addDeclToContext decl = TypeCheckerT . addDeclToContext decl . unTypeCheckerT + addDeclEntryToContext entry = TypeCheckerT . addDeclEntryToContext entry . unTypeCheckerT getFreeCtx = TypeCheckerT . getFreeCtx locallyAdjustCtx p f = TypeCheckerT . locallyAdjustCtx p f . unTypeCheckerT @@ -102,6 +102,7 @@ instance (MonadLogger m) => MonadLogger (TypeCheckerT builtin m) where decrCallDepth = lift decrCallDepth getDebugLevel = lift getDebugLevel logMessage = lift . logMessage + logWarning = lift . logWarning instance (MonadReader r m) => MonadReader r (TypeCheckerT builtin m) where ask = lift ask diff --git a/vehicle/src/Vehicle/Compile/Type/Subsystem/InputOutputInsertion.hs b/vehicle/src/Vehicle/Compile/Type/Subsystem/InputOutputInsertion.hs index 1dc30d2b8..959e8c15d 100644 --- a/vehicle/src/Vehicle/Compile/Type/Subsystem/InputOutputInsertion.hs +++ b/vehicle/src/Vehicle/Compile/Type/Subsystem/InputOutputInsertion.hs @@ -8,7 +8,7 @@ import Vehicle.Compile.Prelude import Vehicle.Compile.Type.Meta.Map (MetaMap (..)) import Vehicle.Compile.Type.Meta.Map qualified as MetaMap import Vehicle.Compile.Type.Monad (TCM, createFreshInstanceConstraint, freshMetaExpr) -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Data.NormalisedExpr import Vehicle.Syntax.Builtin diff --git a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/AnnotationRestrictions.hs b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/AnnotationRestrictions.hs index d5bd53052..3dbb75cf0 100644 --- a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/AnnotationRestrictions.hs +++ b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/AnnotationRestrictions.hs @@ -11,7 +11,7 @@ import Vehicle.Compile.Error import Vehicle.Compile.Prelude import Vehicle.Compile.Type.Monad import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr -------------------------------------------------------------------------------- diff --git a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceBuiltins.hs b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceBuiltins.hs index 72389fe21..10eaa5afb 100644 --- a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceBuiltins.hs +++ b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceBuiltins.hs @@ -10,7 +10,7 @@ import Data.HashMap.Strict qualified as Map import Vehicle.Compile.Type.Constraint.Core import Vehicle.Compile.Type.Core (InstanceCandidate, InstanceCandidateDatabase) import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.DSL import Vehicle.Data.DSL hiding (builtin) import Vehicle.Libraries.StandardLibrary.Definitions diff --git a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceDefaults.hs b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceDefaults.hs index d0fb8ce6d..57d3accd2 100644 --- a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceDefaults.hs +++ b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/InstanceDefaults.hs @@ -8,7 +8,7 @@ import Vehicle.Compile.Type.Constraint.Core (parseInstanceGoal) import Vehicle.Compile.Type.Constraint.InstanceDefaultSolver import Vehicle.Compile.Type.Core import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Value import Vehicle.Data.NormalisedExpr instance HasInstanceDefaults StandardTypingBuiltin where diff --git a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/Type.hs b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/Type.hs index 49940b046..b5eb7698f 100644 --- a/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/Type.hs +++ b/vehicle/src/Vehicle/Compile/Type/Subsystem/Standard/Type.hs @@ -12,6 +12,7 @@ where import Vehicle.Compile.Prelude import Vehicle.Compile.Type.Subsystem.Standard.Core import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.DSL import Vehicle.Data.DSL import Prelude hiding (pi) diff --git a/vehicle/src/Vehicle/Data/BooleanExpr.hs b/vehicle/src/Vehicle/Data/BooleanExpr.hs index 52f564fa8..93995c308 100644 --- a/vehicle/src/Vehicle/Data/BooleanExpr.hs +++ b/vehicle/src/Vehicle/Data/BooleanExpr.hs @@ -9,7 +9,7 @@ import Data.List.NonEmpty (NonEmpty (..)) import Data.List.NonEmpty qualified as NonEmpty import Data.Semigroup (Semigroup (..)) import GHC.Generics (Generic) -import Vehicle.Prelude (Doc, Pretty (..), indent, line, prependList) +import Vehicle.Prelude (Pretty (..), cartesianProduct, indent, line, prependList) -------------------------------------------------------------------------------- -- Triviality @@ -36,6 +36,13 @@ instance (Pretty a) => Pretty (MaybeTrivial a) where Trivial False -> "TriviallyFalse" NonTrivial a -> pretty a +bindMaybeTrivial :: MaybeTrivial a -> (a -> MaybeTrivial b) -> MaybeTrivial b +bindMaybeTrivial (NonTrivial x) f = f x +bindMaybeTrivial (Trivial b) _ = Trivial b + +flattenTrivial :: MaybeTrivial (MaybeTrivial a) -> MaybeTrivial a +flattenTrivial x = bindMaybeTrivial x id + maybeTrivialToEither :: MaybeTrivial a -> Either Bool a maybeTrivialToEither = \case Trivial b -> Left b @@ -66,8 +73,8 @@ andTrivial f x y = case (x, y) of -- BooleanExpr data BooleanExpr a - = Conjunct (BooleanExpr a) (BooleanExpr a) - | Disjunct (BooleanExpr a) (BooleanExpr a) + = Conjunct (ConjunctAll (BooleanExpr a)) + | Disjunct (DisjunctAll (BooleanExpr a)) | Query a deriving (Show, Functor, Foldable, Traversable, Generic) @@ -76,38 +83,42 @@ instance (ToJSON a) => ToJSON (BooleanExpr a) instance (FromJSON a) => FromJSON (BooleanExpr a) instance (Pretty a) => Pretty (BooleanExpr a) where - pretty = prettyBoolExpr pretty - -prettyBoolExpr :: (a -> Doc b) -> (BooleanExpr a -> Doc b) -prettyBoolExpr f = \case - Query x -> f x - Disjunct x y -> "Or" <> line <> indent 2 (prettyBoolExpr f x <> line <> prettyBoolExpr f y) - Conjunct x y -> "And" <> line <> indent 2 (prettyBoolExpr f x <> line <> prettyBoolExpr f y) - -flatten :: BooleanExpr a -> [a] -flatten = \case - Query a -> [a] - Disjunct e1 e2 -> flatten e1 <> flatten e2 - Conjunct e1 e2 -> flatten e1 <> flatten e2 + pretty = \case + Query x -> pretty x + Disjunct xs -> pretty xs + Conjunct xs -> pretty xs evaluate :: (a -> Bool) -> BooleanExpr a -> Bool evaluate f = \case Query v -> f v - Disjunct x y -> evaluate f x || evaluate f y - Conjunct x y -> evaluate f x && evaluate f y + Disjunct xs -> any (evaluate f) xs + Conjunct xs -> all (evaluate f) xs eliminateTrivialAtoms :: BooleanExpr (MaybeTrivial a) -> MaybeTrivial (BooleanExpr a) eliminateTrivialAtoms = \case Query (NonTrivial a) -> NonTrivial (Query a) Query (Trivial b) -> Trivial b - Conjunct a b -> andTrivial Conjunct (eliminateTrivialAtoms a) (eliminateTrivialAtoms b) - Disjunct a b -> orTrivial Disjunct (eliminateTrivialAtoms a) (eliminateTrivialAtoms b) + Conjunct xs -> Conjunct <$> eliminateTrivialConjunctions (fmap eliminateTrivialAtoms xs) + Disjunct xs -> Disjunct <$> eliminateTrivialDisjunctions (fmap eliminateTrivialAtoms xs) + +filterTrivialAtoms :: MaybeTrivial (BooleanExpr (MaybeTrivial a)) -> MaybeTrivial (BooleanExpr a) +filterTrivialAtoms = flattenTrivial . fmap eliminateTrivialAtoms -concatBooleanExpr :: BooleanExpr (BooleanExpr a) -> BooleanExpr a -concatBooleanExpr = \case - Query a -> a - Conjunct a b -> Conjunct (concatBooleanExpr a) (concatBooleanExpr b) - Disjunct a b -> Disjunct (concatBooleanExpr a) (concatBooleanExpr b) +conjunct :: [a] -> MaybeTrivial (BooleanExpr a) +conjunct [] = Trivial True +conjunct (x : xs) = NonTrivial $ Conjunct (ConjunctAll (fmap Query (x :| xs))) + +andBoolExpr :: BooleanExpr a -> BooleanExpr a -> BooleanExpr a +andBoolExpr (Conjunct (ConjunctAll xs)) (Conjunct (ConjunctAll ys)) = Conjunct (ConjunctAll (xs <> ys)) +andBoolExpr (Conjunct (ConjunctAll xs)) y = Conjunct (ConjunctAll ([y] <> xs)) +andBoolExpr x (Conjunct (ConjunctAll ys)) = Conjunct (ConjunctAll ([x] <> ys)) +andBoolExpr x y = Conjunct $ ConjunctAll [x, y] + +orBoolExpr :: BooleanExpr a -> BooleanExpr a -> BooleanExpr a +orBoolExpr (Disjunct (DisjunctAll xs)) (Disjunct (DisjunctAll ys)) = Disjunct (DisjunctAll (xs <> ys)) +orBoolExpr (Disjunct (DisjunctAll xs)) y = Disjunct (DisjunctAll (xs <> [y])) +orBoolExpr x (Disjunct (DisjunctAll ys)) = Disjunct (DisjunctAll ([x] <> ys)) +orBoolExpr x y = Disjunct $ DisjunctAll [x, y] -------------------------------------------------------------------------------- -- Disjunctions @@ -122,7 +133,7 @@ instance (ToJSON a) => ToJSON (DisjunctAll a) instance (FromJSON a) => FromJSON (DisjunctAll a) instance (Pretty a) => Pretty (DisjunctAll a) where - pretty x = "Or" <> pretty (unDisjunctAll x) + pretty x = "Or" <> line <> indent 2 (pretty (unDisjunctAll x)) eliminateTrivialDisjunctions :: DisjunctAll (MaybeTrivial a) -> MaybeTrivial (DisjunctAll a) eliminateTrivialDisjunctions disjunction = do @@ -135,8 +146,8 @@ eliminateTrivialDisjunctions disjunction = do [] -> Trivial False x : xs -> NonTrivial $ DisjunctAll (x :| xs) -concatDisjuncts :: DisjunctAll (DisjunctAll a) -> DisjunctAll a -concatDisjuncts xs = DisjunctAll $ sconcat (coerce xs) +disjunctDisjuncts :: DisjunctAll (DisjunctAll a) -> DisjunctAll a +disjunctDisjuncts xs = DisjunctAll $ sconcat (coerce xs) zipDisjuncts :: NonEmpty a -> DisjunctAll b -> DisjunctAll (a, b) zipDisjuncts xs ys = DisjunctAll $ NonEmpty.zip xs (unDisjunctAll ys) @@ -144,16 +155,27 @@ zipDisjuncts xs ys = DisjunctAll $ NonEmpty.zip xs (unDisjunctAll ys) singletonDisjunct :: a -> DisjunctAll a singletonDisjunct a = DisjunctAll [a] +disjunctsToList :: DisjunctAll a -> [a] +disjunctsToList = NonEmpty.toList . unDisjunctAll + +conjunctDisjuncts :: (a -> b -> c) -> DisjunctAll a -> DisjunctAll b -> DisjunctAll c +conjunctDisjuncts f xs ys = + DisjunctAll $ NonEmpty.fromList (cartesianProduct f (disjunctsToList xs) (disjunctsToList ys)) + -------------------------------------------------------------------------------- -- Conjunctions newtype ConjunctAll a = ConjunctAll { unConjunctAll :: NonEmpty a } - deriving (Show, Semigroup, Functor, Applicative, Monad, Foldable, Traversable) + deriving (Show, Semigroup, Functor, Applicative, Monad, Foldable, Traversable, Generic) instance (Pretty a) => Pretty (ConjunctAll a) where - pretty x = "And" <> pretty (unConjunctAll x) + pretty x = "And" <> line <> indent 2 (pretty (unConjunctAll x)) + +instance (ToJSON a) => ToJSON (ConjunctAll a) + +instance (FromJSON a) => FromJSON (ConjunctAll a) conjunctsToList :: ConjunctAll a -> [a] conjunctsToList = NonEmpty.toList . unConjunctAll @@ -179,22 +201,19 @@ eliminateTrivialConjunctions conjunction = do -- DNF -- | A tree of expressions in disjunctive normal form. -type DNFTree a = MaybeTrivial (DisjunctAll (ConjunctAll a)) +type DNFTree a = DisjunctAll (ConjunctAll a) orDNF :: DNFTree a -> DNFTree a -> DNFTree a -orDNF = orTrivial (<>) +orDNF = (<>) andDNF :: DNFTree a -> DNFTree a -> DNFTree a -andDNF = andTrivial $ \(DisjunctAll cs) (DisjunctAll ds) -> createAllConjunctions cs ds - where - createAllConjunctions cs ds = - DisjunctAll $ NonEmpty.fromList [as <> bs | as <- NonEmpty.toList cs, bs <- NonEmpty.toList ds] +andDNF = conjunctDisjuncts (<>) singletonDNF :: a -> DNFTree a -singletonDNF a = NonTrivial $ DisjunctAll [ConjunctAll [a]] +singletonDNF a = DisjunctAll [ConjunctAll [a]] exprToDNF :: BooleanExpr a -> DNFTree a exprToDNF = \case Query a -> singletonDNF a - Conjunct a b -> andDNF (exprToDNF a) (exprToDNF b) - Disjunct a b -> orDNF (exprToDNF a) (exprToDNF b) + Conjunct xs -> foldr1 andDNF (fmap exprToDNF xs) + Disjunct xs -> foldr1 orDNF (fmap exprToDNF xs) diff --git a/vehicle/src/Vehicle/Data/BuiltinInterface.hs b/vehicle/src/Vehicle/Data/BuiltinInterface.hs index fd1efbab4..4ef160392 100644 --- a/vehicle/src/Vehicle/Data/BuiltinInterface.hs +++ b/vehicle/src/Vehicle/Data/BuiltinInterface.hs @@ -1,10 +1,6 @@ module Vehicle.Data.BuiltinInterface where -import Data.List.NonEmpty (NonEmpty (..)) -import Vehicle.Data.DSL import Vehicle.Data.DeBruijn -import Vehicle.Data.NormalisedExpr -import Vehicle.Libraries.StandardLibrary.Definitions import Vehicle.Prelude import Vehicle.Syntax.AST import Vehicle.Syntax.Builtin @@ -129,392 +125,3 @@ class (PrintableBuiltin builtin) => TypableBuiltin builtin where -- | Construct a type for the builtin typeBuiltin :: Provenance -> builtin -> Type Ix builtin - --------------------------------------------------------------------------------- --- Types DSL - -builtinType :: (HasStandardTypes builtin) => BuiltinType -> DSLExpr builtin -builtinType = builtin . mkBuiltinType - -tUnit :: (HasStandardTypes builtin) => DSLExpr builtin -tUnit = builtinType Unit - -tBool, tNat, tInt, tRat :: (HasStandardTypes builtin) => DSLExpr builtin -tBool = builtinType Bool -tNat = builtinType Nat -tInt = builtinType Int -tRat = builtinType Rat - -tVector :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -tVector tElem dim = builtinType Vector @@ [tElem] .@@ [dim] - -tVectorFunctor :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin -tVectorFunctor n = explLam "A" type0 (`tVector` n) - -tListRaw :: (HasStandardTypes builtin) => DSLExpr builtin -tListRaw = builtinType List - -tList :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin -tList tElem = tListRaw @@ [tElem] - -tIndex :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin -tIndex n = builtinType Index .@@ [n] - -forAllNat :: (HasStandardTypes builtin) => (DSLExpr builtin -> DSLExpr builtin) -> DSLExpr builtin -forAllNat = forAll "n" tNat - -forAllIrrelevantNat :: (HasStandardTypes builtin) => Name -> (DSLExpr builtin -> DSLExpr builtin) -> DSLExpr builtin -forAllIrrelevantNat name = pi (Just name) (Implicit False) Irrelevant tNat - -irrelImplNatLam :: (HasStandardTypes builtin) => Name -> (DSLExpr builtin -> DSLExpr builtin) -> DSLExpr builtin -irrelImplNatLam n = lam n (Implicit False) Irrelevant tNat - -natInDomainConstraint :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -natInDomainConstraint n t = builtin mkNatInDomainConstraint @@ [n, t] - --------------------------------------------------------------------------------- --- Type exprs - -pattern NullaryTypeExpr :: (HasStandardTypes builtin) => Provenance -> BuiltinType -> Expr var builtin -pattern NullaryTypeExpr p b <- Builtin p (getBuiltinType -> Just b) - where - NullaryTypeExpr p b = Builtin p (mkBuiltinType b) - -pattern TypeExpr :: - (HasStandardTypes builtin) => - Provenance -> - BuiltinType -> - NonEmpty (Arg var builtin) -> - Expr var builtin -pattern TypeExpr p b args <- BuiltinExpr p (getBuiltinType -> Just b) args - where - TypeExpr p b args = BuiltinExpr p (mkBuiltinType b) args - -pattern BoolType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin -pattern BoolType p = NullaryTypeExpr p Bool - -pattern NatType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin -pattern NatType p = NullaryTypeExpr p Nat - -pattern IntType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin -pattern IntType p = NullaryTypeExpr p Int - -pattern RatType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin -pattern RatType p = NullaryTypeExpr p Rat - -pattern ListType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin -> Expr var builtin -pattern ListType p tElem <- TypeExpr p List [RelevantExplicitArg _ tElem] - -pattern RawListType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin -pattern RawListType p = NullaryTypeExpr p List - -pattern VectorType :: - (HasStandardTypes builtin) => - Provenance -> - Expr var builtin -> - Expr var builtin -> - Expr var builtin -pattern VectorType p tElem tDim <- - TypeExpr - p - Vector - [ RelevantExplicitArg _ tElem, - IrrelevantExplicitArg _ tDim - ] - --------------------------------------------------------------------------------- --- Type values - -pattern VBuiltinType :: (HasStandardTypes builtin) => BuiltinType -> WHNFSpine builtin -> WHNFType builtin -pattern VBuiltinType c args <- VBuiltin (getBuiltinType -> Just c) args - where - VBuiltinType c args = VBuiltin (mkBuiltinType c) args - -pattern VBoolType :: (HasStandardTypes builtin) => WHNFType builtin -pattern VBoolType <- VBuiltinType Bool [] - where - VBoolType = VBuiltinType Bool [] - -pattern VIndexType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFType builtin -pattern VIndexType size <- VBuiltinType Index [IrrelevantExplicitArg _ size] - -pattern VNatType :: (HasStandardTypes builtin) => WHNFType builtin -pattern VNatType <- VBuiltinType Nat [] - where - VNatType = VBuiltinType Nat [] - -pattern VIntType :: (HasStandardTypes builtin) => WHNFType builtin -pattern VIntType <- VBuiltinType Int [] - where - VIntType = VBuiltinType Int [] - -pattern VRatType :: (HasStandardTypes builtin) => WHNFType builtin -pattern VRatType <- VBuiltinType Rat [] - where - VRatType = VBuiltinType Rat [] - -pattern VRawListType :: (HasStandardTypes builtin) => WHNFType builtin -pattern VRawListType <- VBuiltinType List [] - where - VRawListType = VBuiltinType List [] - -pattern VListType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFType builtin -pattern VListType tElem <- VBuiltinType List [RelevantExplicitArg _ tElem] - -pattern VVectorType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFValue builtin -> WHNFType builtin -pattern VVectorType tElem dim <- VBuiltinType Vector [RelevantExplicitArg _ tElem, IrrelevantExplicitArg _ dim] - -pattern VTensorType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFValue builtin -> WHNFType builtin -pattern VTensorType tElem dims <- - VFreeVar TensorIdent [RelevantExplicitArg _ tElem, RelevantExplicitArg _ dims] - -mkVVectorType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFValue builtin -> WHNFType builtin -mkVVectorType tElem dim = - VBuiltinType - Vector - [ Arg mempty Explicit Relevant tElem, - Arg mempty Explicit Irrelevant dim - ] - --------------------------------------------------------------------------------- --- Constructors DSL - -builtinConstructor :: (HasStandardData builtin) => BuiltinConstructor -> DSLExpr builtin -builtinConstructor = builtin . mkBuiltinConstructor - -nil :: (HasStandardData builtin) => DSLExpr builtin -> DSLExpr builtin -nil tElem = builtinConstructor Nil @@@ [tElem] - -cons :: (HasStandardData builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -cons tElem x xs = builtinConstructor Cons @@@ [tElem] @@ [x, xs] - -natLit :: (HasStandardData builtin) => Int -> DSLExpr builtin -natLit n = builtinConstructor (LNat n) - -boolLit :: (HasStandardData builtin) => Bool -> DSLExpr builtin -boolLit n = builtinConstructor (LBool n) - -ratLit :: (HasStandardData builtin) => Rational -> DSLExpr builtin -ratLit r = builtinConstructor (LRat r) - -unitLit :: (HasStandardData builtin) => DSLExpr builtin -unitLit = builtinConstructor LUnit - --------------------------------------------------------------------------------- --- Expr constructors patterns - -pattern UnitLiteral :: (HasStandardData builtin) => Provenance -> Expr var builtin -pattern UnitLiteral p <- Builtin p (getBuiltinConstructor -> Just LUnit) - where - UnitLiteral p = Builtin p (mkBuiltinConstructor LUnit) - -pattern BoolLiteral :: (HasStandardData builtin) => Provenance -> Bool -> Expr var builtin -pattern BoolLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LBool n)) - where - BoolLiteral p n = Builtin p (mkBuiltinConstructor (LBool n)) - -pattern TrueExpr :: (HasStandardData builtin) => Provenance -> Expr var builtin -pattern TrueExpr p = BoolLiteral p True - -pattern FalseExpr :: (HasStandardData builtin) => Provenance -> Expr var builtin -pattern FalseExpr p = BoolLiteral p False - -pattern IndexLiteral :: (HasStandardData builtin) => Provenance -> Int -> Expr var builtin -pattern IndexLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LIndex n)) - where - IndexLiteral p n = Builtin p (mkBuiltinConstructor (LIndex n)) - -pattern NatLiteral :: (HasStandardData builtin) => Provenance -> Int -> Expr var builtin -pattern NatLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LNat n)) - where - NatLiteral p n = Builtin p (mkBuiltinConstructor (LNat n)) - -pattern IntLiteral :: (HasStandardData builtin) => Provenance -> Int -> Expr var builtin -pattern IntLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LInt n)) - where - IntLiteral p n = Builtin p (mkBuiltinConstructor (LInt n)) - -pattern RatLiteral :: (HasStandardData builtin) => Provenance -> Rational -> Expr var builtin -pattern RatLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LRat n)) - where - RatLiteral p n = Builtin p (mkBuiltinConstructor (LRat n)) - -pattern AnnExpr :: (HasStandardData builtin) => Provenance -> Type var builtin -> Expr var builtin -> Expr var builtin -pattern AnnExpr p t e <- BuiltinExpr p (getBuiltinFunction -> Just Ann) [ExplicitArg _ _ t, ExplicitArg _ _ e] - -pattern VecLiteral :: - (HasStandardData builtin) => - Provenance -> - Expr var builtin -> - [Arg var builtin] -> - Expr var builtin -pattern VecLiteral p tElem xs <- - BuiltinExpr p (getBuiltinConstructor -> Just (LVec _)) (RelevantImplicitArg _ tElem :| xs) - -mkList :: - forall var builtin. - (HasStandardData builtin) => - Provenance -> - Expr var builtin -> - [Expr var builtin] -> - Expr var builtin -mkList p elemType = foldr mkCons mkNil - where - mkNil :: Expr var builtin - mkNil = BuiltinExpr p (mkBuiltinConstructor Nil) [Arg p (Implicit True) Relevant elemType] - - mkCons :: - (HasStandardData builtin) => - Expr var builtin -> - Expr var builtin -> - Expr var builtin - mkCons x xs = - BuiltinExpr - p - (mkBuiltinConstructor Cons) - ( Arg p (Implicit True) Relevant elemType - :| [ Arg p Explicit Relevant x, - Arg p Explicit Relevant xs - ] - ) - --------------------------------------------------------------------------------- --- WHNFValue constructors patterns - -pattern VUnitLiteral :: (HasStandardData builtin) => Value strategy builtin -pattern VUnitLiteral <- VBuiltin (getBuiltinConstructor -> Just LUnit) [] - where - VUnitLiteral = VBuiltin (mkBuiltinConstructor LUnit) [] - -pattern VBoolLiteral :: (HasStandardData builtin) => Bool -> Value strategy builtin -pattern VBoolLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LBool x)) [] - where - VBoolLiteral x = VBuiltin (mkBuiltinConstructor (LBool x)) [] - -pattern VIndexLiteral :: (HasStandardData builtin) => Int -> Value strategy builtin -pattern VIndexLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LIndex x)) [] - where - VIndexLiteral x = VBuiltin (mkBuiltinConstructor (LIndex x)) [] - -pattern VNatLiteral :: (HasStandardData builtin) => Int -> Value strategy builtin -pattern VNatLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LNat x)) [] - where - VNatLiteral x = VBuiltin (mkBuiltinConstructor (LNat x)) [] - -pattern VIntLiteral :: (HasStandardData builtin) => Int -> Value strategy builtin -pattern VIntLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LInt x)) [] - where - VIntLiteral x = VBuiltin (mkBuiltinConstructor (LInt x)) [] - -pattern VRatLiteral :: (HasStandardData builtin) => Rational -> Value strategy builtin -pattern VRatLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LRat x)) [] - where - VRatLiteral x = VBuiltin (mkBuiltinConstructor (LRat x)) [] - -pattern VNil :: (HasStandardData builtin) => Value strategy builtin -pattern VNil <- VBuiltin (getBuiltinConstructor -> Just Nil) _ - --- TODO should definitely be `isRelevant` not `isExplicit` -pattern VCons :: (HasStandardData builtin) => VArg strategy builtin -> VArg strategy builtin -> Value strategy builtin -pattern VCons x xs <- VBuiltin (getBuiltinConstructor -> Just Cons) (filter isExplicit -> [x, xs]) - --- TODO should definitely be `isRelevant` not `isExplicit` -pattern VVecLiteral :: (HasStandardData builtin) => [VArg strategy builtin] -> Value strategy builtin -pattern VVecLiteral xs <- VBuiltin (getBuiltinConstructor -> Just (LVec _)) (filter isExplicit -> xs) - -mkVList :: (HasStandardData builtin) => [Value strategy builtin] -> Value strategy builtin -mkVList = foldr mkCons mkNil - where - mkNil = VBuiltin (mkBuiltinConstructor Nil) [] - mkCons y ys = VBuiltin (mkBuiltinConstructor Cons) (Arg mempty Explicit Relevant <$> [y, ys]) - -mkVLVec :: (HasStandardData builtin) => [Value strategy builtin] -> Value strategy builtin -mkVLVec xs = - VBuiltin - (mkBuiltinConstructor (LVec (length xs))) - (Arg mempty (Implicit True) Relevant VUnitLiteral : (Arg mempty Explicit Relevant <$> xs)) - -getNatLiteral :: (HasStandardData builtin) => Value strategy builtin -> Maybe Int -getNatLiteral = \case - VNatLiteral d -> Just d - _ -> Nothing - --------------------------------------------------------------------------------- --- Functions DSL - -builtinFunction :: (HasStandardData builtin) => BuiltinFunction -> DSLExpr builtin -builtinFunction = builtin . mkBuiltinFunction - -addNat :: (HasStandardData builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -addNat x y = builtinFunction (Add AddNat) @@ [x, y] - -ite :: - (HasStandardData builtin) => - DSLExpr builtin -> - DSLExpr builtin -> - DSLExpr builtin -> - DSLExpr builtin -> - DSLExpr builtin -ite t c e1 e2 = builtinFunction If @@@ [t] @@ [c, e1, e2] - --------------------------------------------------------------------------------- --- WHNFValue Function patterns - -pattern VBuiltinFunction :: (HasStandardData builtin) => BuiltinFunction -> WHNFSpine builtin -> WHNFValue builtin -pattern VBuiltinFunction f args <- VBuiltin (getBuiltinFunction -> Just f) args - where - VBuiltinFunction f args = VBuiltin (mkBuiltinFunction f) args - --------------------------------------------------------------------------------- --- Type classes - -builtinTypeClass :: (HasStandardTypeClasses builtin) => TypeClass -> DSLExpr builtin -builtinTypeClass = builtin . mkBuiltinTypeClass - -typeClass :: (HasStandardTypeClasses builtin) => TypeClass -> NonEmpty (DSLExpr builtin) -> DSLExpr builtin -typeClass tc args = builtinTypeClass tc @@ args - -hasEq :: (HasStandardTypeClasses builtin) => EqualityOp -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasEq eq t1 t2 = typeClass (HasEq eq) [t1, t2] - -hasOrd :: (HasStandardTypeClasses builtin) => OrderOp -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasOrd ord t1 t2 = typeClass (HasOrd ord) [t1, t2] - -hasQuantifier :: (HasStandardTypeClasses builtin) => Quantifier -> DSLExpr builtin -> DSLExpr builtin -hasQuantifier q t = typeClass (HasQuantifier q) [t] - -numOp2TypeClass :: (HasStandardTypeClasses builtin) => TypeClass -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -numOp2TypeClass tc t1 t2 t3 = typeClass tc [t1, t2, t3] - -hasAdd :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasAdd = numOp2TypeClass HasAdd - -hasSub :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasSub = numOp2TypeClass HasSub - -hasMul :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasMul = numOp2TypeClass HasMul - -hasDiv :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasDiv = numOp2TypeClass HasDiv - -hasNeg :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasNeg t1 t2 = typeClass HasNeg [t1, t2] - -hasMap :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -hasMap tCont = typeClass HasMap [tCont] - -hasFold :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -hasFold tCont = typeClass HasFold [tCont] - -hasQuantifierIn :: (HasStandardTypeClasses builtin) => Quantifier -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasQuantifierIn q tCont tElem tRes = typeClass (HasQuantifierIn q) [tCont, tElem, tRes] - -hasNatLits :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -hasNatLits t = typeClass HasNatLits [t] - -hasRatLits :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -hasRatLits t = typeClass HasRatLits [t] - -hasVecLits :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -hasVecLits n d = typeClass HasVecLits [n, d] diff --git a/vehicle/src/Vehicle/Data/BuiltinInterface/DSL.hs b/vehicle/src/Vehicle/Data/BuiltinInterface/DSL.hs new file mode 100644 index 000000000..236e198d0 --- /dev/null +++ b/vehicle/src/Vehicle/Data/BuiltinInterface/DSL.hs @@ -0,0 +1,146 @@ +module Vehicle.Data.BuiltinInterface.DSL where + +import Data.List.NonEmpty (NonEmpty (..)) +import Vehicle.Data.BuiltinInterface +import Vehicle.Data.DSL +import Vehicle.Syntax.AST +import Vehicle.Syntax.Builtin +import Prelude hiding (pi) + +-------------------------------------------------------------------------------- +-- Types DSL + +builtinType :: (HasStandardTypes builtin) => BuiltinType -> DSLExpr builtin +builtinType = builtin . mkBuiltinType + +tUnit :: (HasStandardTypes builtin) => DSLExpr builtin +tUnit = builtinType Unit + +tBool, tNat, tInt, tRat :: (HasStandardTypes builtin) => DSLExpr builtin +tBool = builtinType Bool +tNat = builtinType Nat +tInt = builtinType Int +tRat = builtinType Rat + +tVector :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +tVector tElem dim = builtinType Vector @@ [tElem] .@@ [dim] + +tVectorFunctor :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin +tVectorFunctor n = explLam "A" type0 (`tVector` n) + +tListRaw :: (HasStandardTypes builtin) => DSLExpr builtin +tListRaw = builtinType List + +tList :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin +tList tElem = tListRaw @@ [tElem] + +tIndex :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin +tIndex n = builtinType Index .@@ [n] + +forAllNat :: (HasStandardTypes builtin) => (DSLExpr builtin -> DSLExpr builtin) -> DSLExpr builtin +forAllNat = forAll "n" tNat + +forAllIrrelevantNat :: (HasStandardTypes builtin) => Name -> (DSLExpr builtin -> DSLExpr builtin) -> DSLExpr builtin +forAllIrrelevantNat name = pi (Just name) (Implicit False) Irrelevant tNat + +irrelImplNatLam :: (HasStandardTypes builtin) => Name -> (DSLExpr builtin -> DSLExpr builtin) -> DSLExpr builtin +irrelImplNatLam n = lam n (Implicit False) Irrelevant tNat + +natInDomainConstraint :: (HasStandardTypes builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +natInDomainConstraint n t = builtin mkNatInDomainConstraint @@ [n, t] + +-------------------------------------------------------------------------------- +-- Constructors DSL + +builtinConstructor :: (HasStandardData builtin) => BuiltinConstructor -> DSLExpr builtin +builtinConstructor = builtin . mkBuiltinConstructor + +nil :: (HasStandardData builtin) => DSLExpr builtin -> DSLExpr builtin +nil tElem = builtinConstructor Nil @@@ [tElem] + +cons :: (HasStandardData builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +cons tElem x xs = builtinConstructor Cons @@@ [tElem] @@ [x, xs] + +natLit :: (HasStandardData builtin) => Int -> DSLExpr builtin +natLit n = builtinConstructor (LNat n) + +boolLit :: (HasStandardData builtin) => Bool -> DSLExpr builtin +boolLit n = builtinConstructor (LBool n) + +ratLit :: (HasStandardData builtin) => Rational -> DSLExpr builtin +ratLit r = builtinConstructor (LRat r) + +unitLit :: (HasStandardData builtin) => DSLExpr builtin +unitLit = builtinConstructor LUnit + +-------------------------------------------------------------------------------- +-- Functions DSL + +builtinFunction :: (HasStandardData builtin) => BuiltinFunction -> DSLExpr builtin +builtinFunction = builtin . mkBuiltinFunction + +addNat :: (HasStandardData builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +addNat x y = builtinFunction (Add AddNat) @@ [x, y] + +ite :: + (HasStandardData builtin) => + DSLExpr builtin -> + DSLExpr builtin -> + DSLExpr builtin -> + DSLExpr builtin -> + DSLExpr builtin +ite t c e1 e2 = builtinFunction If @@@ [t] @@ [c, e1, e2] + +-------------------------------------------------------------------------------- +-- Type classes + +builtinTypeClass :: (HasStandardTypeClasses builtin) => TypeClass -> DSLExpr builtin +builtinTypeClass = builtin . mkBuiltinTypeClass + +typeClass :: (HasStandardTypeClasses builtin) => TypeClass -> NonEmpty (DSLExpr builtin) -> DSLExpr builtin +typeClass tc args = builtinTypeClass tc @@ args + +hasEq :: (HasStandardTypeClasses builtin) => EqualityOp -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasEq eq t1 t2 = typeClass (HasEq eq) [t1, t2] + +hasOrd :: (HasStandardTypeClasses builtin) => OrderOp -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasOrd ord t1 t2 = typeClass (HasOrd ord) [t1, t2] + +hasQuantifier :: (HasStandardTypeClasses builtin) => Quantifier -> DSLExpr builtin -> DSLExpr builtin +hasQuantifier q t = typeClass (HasQuantifier q) [t] + +numOp2TypeClass :: (HasStandardTypeClasses builtin) => TypeClass -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +numOp2TypeClass tc t1 t2 t3 = typeClass tc [t1, t2, t3] + +hasAdd :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasAdd = numOp2TypeClass HasAdd + +hasSub :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasSub = numOp2TypeClass HasSub + +hasMul :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasMul = numOp2TypeClass HasMul + +hasDiv :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasDiv = numOp2TypeClass HasDiv + +hasNeg :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasNeg t1 t2 = typeClass HasNeg [t1, t2] + +hasMap :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin +hasMap tCont = typeClass HasMap [tCont] + +hasFold :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin +hasFold tCont = typeClass HasFold [tCont] + +hasQuantifierIn :: (HasStandardTypeClasses builtin) => Quantifier -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasQuantifierIn q tCont tElem tRes = typeClass (HasQuantifierIn q) [tCont, tElem, tRes] + +hasNatLits :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin +hasNatLits t = typeClass HasNatLits [t] + +hasRatLits :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin +hasRatLits t = typeClass HasRatLits [t] + +hasVecLits :: (HasStandardTypeClasses builtin) => DSLExpr builtin -> DSLExpr builtin -> DSLExpr builtin +hasVecLits n d = typeClass HasVecLits [n, d] diff --git a/vehicle/src/Vehicle/Data/BuiltinInterface/Expr.hs b/vehicle/src/Vehicle/Data/BuiltinInterface/Expr.hs new file mode 100644 index 000000000..ebc69d85f --- /dev/null +++ b/vehicle/src/Vehicle/Data/BuiltinInterface/Expr.hs @@ -0,0 +1,260 @@ +module Vehicle.Data.BuiltinInterface.Expr where + +import Data.List.NonEmpty (NonEmpty (..)) +import Vehicle.Data.BuiltinInterface +import Vehicle.Syntax.AST +import Vehicle.Syntax.Builtin +import Prelude hiding (pi) + +-------------------------------------------------------------------------------- +-- Type exprs + +pattern NullaryTypeExpr :: (HasStandardTypes builtin) => Provenance -> BuiltinType -> Expr var builtin +pattern NullaryTypeExpr p b <- Builtin p (getBuiltinType -> Just b) + where + NullaryTypeExpr p b = Builtin p (mkBuiltinType b) + +pattern TypeExpr :: + (HasStandardTypes builtin) => + Provenance -> + BuiltinType -> + NonEmpty (Arg var builtin) -> + Expr var builtin +pattern TypeExpr p b args <- BuiltinExpr p (getBuiltinType -> Just b) args + where + TypeExpr p b args = BuiltinExpr p (mkBuiltinType b) args + +pattern BoolType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin +pattern BoolType p = NullaryTypeExpr p Bool + +pattern NatType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin +pattern NatType p = NullaryTypeExpr p Nat + +pattern IntType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin +pattern IntType p = NullaryTypeExpr p Int + +pattern RatType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin +pattern RatType p = NullaryTypeExpr p Rat + +pattern ListType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin -> Expr var builtin +pattern ListType p tElem <- TypeExpr p List [RelevantExplicitArg _ tElem] + +pattern RawListType :: (HasStandardTypes builtin) => Provenance -> Expr var builtin +pattern RawListType p = NullaryTypeExpr p List + +pattern VectorType :: + (HasStandardTypes builtin) => + Provenance -> + Expr var builtin -> + Expr var builtin -> + Expr var builtin +pattern VectorType p tElem tDim <- + TypeExpr + p + Vector + [ RelevantExplicitArg _ tElem, + IrrelevantExplicitArg _ tDim + ] + +-------------------------------------------------------------------------------- +-- Expr constructors patterns + +pattern UnitLiteral :: (HasStandardData builtin) => Provenance -> Expr var builtin +pattern UnitLiteral p <- Builtin p (getBuiltinConstructor -> Just LUnit) + where + UnitLiteral p = Builtin p (mkBuiltinConstructor LUnit) + +pattern BoolLiteral :: (HasStandardData builtin) => Provenance -> Bool -> Expr var builtin +pattern BoolLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LBool n)) + where + BoolLiteral p n = Builtin p (mkBuiltinConstructor (LBool n)) + +pattern TrueExpr :: (HasStandardData builtin) => Provenance -> Expr var builtin +pattern TrueExpr p = BoolLiteral p True + +pattern FalseExpr :: (HasStandardData builtin) => Provenance -> Expr var builtin +pattern FalseExpr p = BoolLiteral p False + +pattern IndexLiteral :: (HasStandardData builtin) => Provenance -> Int -> Expr var builtin +pattern IndexLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LIndex n)) + where + IndexLiteral p n = Builtin p (mkBuiltinConstructor (LIndex n)) + +pattern NatLiteral :: (HasStandardData builtin) => Provenance -> Int -> Expr var builtin +pattern NatLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LNat n)) + where + NatLiteral p n = Builtin p (mkBuiltinConstructor (LNat n)) + +pattern IntLiteral :: (HasStandardData builtin) => Provenance -> Int -> Expr var builtin +pattern IntLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LInt n)) + where + IntLiteral p n = Builtin p (mkBuiltinConstructor (LInt n)) + +pattern RatLiteral :: (HasStandardData builtin) => Provenance -> Rational -> Expr var builtin +pattern RatLiteral p n <- Builtin p (getBuiltinConstructor -> Just (LRat n)) + where + RatLiteral p n = Builtin p (mkBuiltinConstructor (LRat n)) + +pattern AnnExpr :: (HasStandardData builtin) => Provenance -> Type var builtin -> Expr var builtin -> Expr var builtin +pattern AnnExpr p t e <- BuiltinExpr p (getBuiltinFunction -> Just Ann) [ExplicitArg _ _ t, ExplicitArg _ _ e] + +pattern VecLiteral :: + (HasStandardData builtin) => + Provenance -> + Expr var builtin -> + [Arg var builtin] -> + Expr var builtin +pattern VecLiteral p tElem xs <- + BuiltinExpr p (getBuiltinConstructor -> Just (LVec _)) (RelevantImplicitArg _ tElem :| xs) + +mkList :: + forall var builtin. + (HasStandardData builtin) => + Provenance -> + Expr var builtin -> + [Expr var builtin] -> + Expr var builtin +mkList p elemType = foldr mkCons mkNil + where + mkNil :: Expr var builtin + mkNil = BuiltinExpr p (mkBuiltinConstructor Nil) [Arg p (Implicit True) Relevant elemType] + + mkCons :: + (HasStandardData builtin) => + Expr var builtin -> + Expr var builtin -> + Expr var builtin + mkCons x xs = + BuiltinExpr + p + (mkBuiltinConstructor Cons) + ( Arg p (Implicit True) Relevant elemType + :| [ Arg p Explicit Relevant x, + Arg p Explicit Relevant xs + ] + ) + +-------------------------------------------------------------------------------- +-- Boolean operations + +pattern BuiltinFunctionExpr :: + (HasStandardData builtin) => + Provenance -> + BuiltinFunction -> + NonEmpty (Arg var builtin) -> + Expr var builtin +pattern BuiltinFunctionExpr p b args <- BuiltinExpr p (getBuiltinFunction -> Just b) args + where + BuiltinFunctionExpr p b args = BuiltinExpr p (mkBuiltinFunction b) args + +pattern QuantifierExpr :: + (HasStandardData builtin) => + Provenance -> + Quantifier -> + Binder var builtin -> + Expr var builtin -> + Expr var builtin +pattern QuantifierExpr p q binder body <- + BuiltinFunctionExpr + p + (Quantifier q) + [ RelevantExplicitArg _ (Lam _ binder body) + ] + where + QuantifierExpr p q binder body = + BuiltinFunctionExpr + p + (Quantifier q) + [ Arg p Explicit Relevant (Lam p binder body) + ] + +pattern ExistsExpr :: + (HasStandardData builtin) => + Provenance -> + Binder var builtin -> + Expr var builtin -> + Expr var builtin +pattern ExistsExpr p binder body = + QuantifierExpr p Exists binder body + +pattern ForallExpr :: + (HasStandardData builtin) => + Provenance -> + Binder var builtin -> + Expr var builtin -> + Expr var builtin +pattern ForallExpr p binder body = + QuantifierExpr p Forall binder body + +pattern BooleanOp2Expr :: + (HasStandardData builtin) => + BuiltinFunction -> + Provenance -> + NonEmpty (Arg var builtin) -> + Expr var builtin +pattern BooleanOp2Expr op p explicitArgs = BuiltinFunctionExpr p op explicitArgs + +pattern AndExpr :: + (HasStandardData builtin) => + Provenance -> + NonEmpty (Arg var builtin) -> + Expr var builtin +pattern AndExpr p explicitArgs = BooleanOp2Expr And p explicitArgs + +pattern OrExpr :: + (HasStandardData builtin) => + Provenance -> + NonEmpty (Arg var builtin) -> + Expr var builtin +pattern OrExpr p explicitArgs = BooleanOp2Expr Or p explicitArgs + +pattern ImpliesExpr :: + (HasStandardData builtin) => + Provenance -> + NonEmpty (Arg var builtin) -> + Expr var builtin +pattern ImpliesExpr p explicitArgs = BooleanOp2Expr Implies p explicitArgs + +pattern NotExpr :: + (HasStandardData builtin) => + Provenance -> + NonEmpty (Arg var builtin) -> + Expr var builtin +pattern NotExpr p explicitArgs = BuiltinFunctionExpr p Not explicitArgs + +pattern EqualityExpr :: + Provenance -> + EqualityDomain -> + EqualityOp -> + NonEmpty (Arg var Builtin) -> + Expr var Builtin +pattern EqualityExpr p dom op args = BuiltinFunctionExpr p (Equals dom op) args + +pattern OrderExpr :: + Provenance -> + OrderDomain -> + OrderOp -> + NonEmpty (Arg var Builtin) -> + Expr var Builtin +pattern OrderExpr p dom op args = BuiltinFunctionExpr p (Order dom op) args + +pattern IfExpr :: + Provenance -> + Expr var Builtin -> + [Arg var Builtin] -> + Expr var Builtin +pattern IfExpr p tRes args <- + BuiltinFunctionExpr + p + If + ( RelevantImplicitArg _ tRes + :| args + ) + where + IfExpr p tRes args = + BuiltinFunctionExpr + p + If + ( Arg p (Implicit True) Relevant tRes + :| args + ) diff --git a/vehicle/src/Vehicle/Data/BuiltinInterface/Value.hs b/vehicle/src/Vehicle/Data/BuiltinInterface/Value.hs new file mode 100644 index 000000000..d1e26204f --- /dev/null +++ b/vehicle/src/Vehicle/Data/BuiltinInterface/Value.hs @@ -0,0 +1,191 @@ +module Vehicle.Data.BuiltinInterface.Value where + +import Vehicle.Data.BuiltinInterface +import Vehicle.Data.NormalisedExpr +import Vehicle.Libraries.StandardLibrary.Definitions +import Vehicle.Syntax.AST +import Vehicle.Syntax.Builtin +import Prelude hiding (pi) + +-------------------------------------------------------------------------------- +-- Type values + +pattern VBuiltinType :: (HasStandardTypes builtin) => BuiltinType -> WHNFSpine builtin -> WHNFType builtin +pattern VBuiltinType c args <- VBuiltin (getBuiltinType -> Just c) args + where + VBuiltinType c args = VBuiltin (mkBuiltinType c) args + +-- Can't use `[]` in a bidrectional pattern synonym until GHC 9.4.3?? +pattern VRawBuiltinType :: (HasStandardTypes builtin) => BuiltinType -> WHNFType builtin +pattern VRawBuiltinType t <- VBuiltinType t [] + where + VRawBuiltinType t = VBuiltinType t [] + +pattern VUnitType :: (HasStandardTypes builtin) => WHNFType builtin +pattern VUnitType = VRawBuiltinType Unit + +pattern VBoolType :: (HasStandardTypes builtin) => WHNFType builtin +pattern VBoolType = VRawBuiltinType Bool + +pattern VIndexType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFType builtin +pattern VIndexType size <- VBuiltinType Index [IrrelevantExplicitArg _ size] + +pattern VNatType :: (HasStandardTypes builtin) => WHNFType builtin +pattern VNatType = VRawBuiltinType Nat + +pattern VIntType :: (HasStandardTypes builtin) => WHNFType builtin +pattern VIntType = VRawBuiltinType Int + +pattern VRatType :: (HasStandardTypes builtin) => WHNFType builtin +pattern VRatType = VRawBuiltinType Rat + +pattern VRawListType :: (HasStandardTypes builtin) => WHNFType builtin +pattern VRawListType = VRawBuiltinType List + +pattern VListType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFType builtin +pattern VListType tElem <- VBuiltinType List [RelevantExplicitArg _ tElem] + +pattern VVectorType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFValue builtin -> WHNFType builtin +pattern VVectorType tElem dim <- VBuiltinType Vector [RelevantExplicitArg _ tElem, IrrelevantExplicitArg _ dim] + +pattern VTensorType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFValue builtin -> WHNFType builtin +pattern VTensorType tElem dims <- + VFreeVar TensorIdent [RelevantExplicitArg _ tElem, RelevantExplicitArg _ dims] + +mkVVectorType :: (HasStandardTypes builtin) => WHNFType builtin -> WHNFValue builtin -> WHNFType builtin +mkVVectorType tElem dim = + VBuiltinType + Vector + [ Arg mempty Explicit Relevant tElem, + Arg mempty Explicit Irrelevant dim + ] + +-------------------------------------------------------------------------------- +-- WHNFValue constructors patterns + +pattern VUnitLiteral :: (HasStandardData builtin) => Value strategy builtin +pattern VUnitLiteral <- VBuiltin (getBuiltinConstructor -> Just LUnit) [] + where + VUnitLiteral = VBuiltin (mkBuiltinConstructor LUnit) [] + +pattern VBoolLiteral :: (HasStandardData builtin) => Bool -> Value strategy builtin +pattern VBoolLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LBool x)) [] + where + VBoolLiteral x = VBuiltin (mkBuiltinConstructor (LBool x)) [] + +pattern VIndexLiteral :: (HasStandardData builtin) => Int -> Value strategy builtin +pattern VIndexLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LIndex x)) [] + where + VIndexLiteral x = VBuiltin (mkBuiltinConstructor (LIndex x)) [] + +pattern VNatLiteral :: (HasStandardData builtin) => Int -> Value strategy builtin +pattern VNatLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LNat x)) [] + where + VNatLiteral x = VBuiltin (mkBuiltinConstructor (LNat x)) [] + +pattern VIntLiteral :: (HasStandardData builtin) => Int -> Value strategy builtin +pattern VIntLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LInt x)) [] + where + VIntLiteral x = VBuiltin (mkBuiltinConstructor (LInt x)) [] + +pattern VRatLiteral :: (HasStandardData builtin) => Rational -> Value strategy builtin +pattern VRatLiteral x <- VBuiltin (getBuiltinConstructor -> Just (LRat x)) [] + where + VRatLiteral x = VBuiltin (mkBuiltinConstructor (LRat x)) [] + +pattern VNil :: (HasStandardData builtin) => Value strategy builtin +pattern VNil <- VBuiltin (getBuiltinConstructor -> Just Nil) _ + where + VNil = VBuiltin (mkBuiltinConstructor Nil) [] + +-- TODO should definitely be `isRelevant` not `isExplicit` +pattern VCons :: (HasStandardData builtin) => VArg strategy builtin -> VArg strategy builtin -> Value strategy builtin +pattern VCons x xs <- VBuiltin (getBuiltinConstructor -> Just Cons) (filter isExplicit -> [x, xs]) + +-- TODO should definitely be `isRelevant` not `isExplicit` +pattern VVecLiteral :: (HasStandardData builtin) => [VArg strategy builtin] -> Value strategy builtin +pattern VVecLiteral xs <- VBuiltin (getBuiltinConstructor -> Just (LVec _)) (filter isExplicit -> xs) + +mkVList :: (HasStandardData builtin) => [Value strategy builtin] -> Value strategy builtin +mkVList = foldr mkCons mkNil + where + mkNil = VBuiltin (mkBuiltinConstructor Nil) [] + mkCons y ys = VBuiltin (mkBuiltinConstructor Cons) (Arg mempty Explicit Relevant <$> [y, ys]) + +mkVLVec :: (HasStandardData builtin) => [Value strategy builtin] -> Value strategy builtin +mkVLVec xs = + VBuiltin + (mkBuiltinConstructor (LVec (length xs))) + (Arg mempty (Implicit True) Relevant VUnitLiteral : (Arg mempty Explicit Relevant <$> xs)) + +getNatLiteral :: (HasStandardData builtin) => Value strategy builtin -> Maybe Int +getNatLiteral = \case + VNatLiteral d -> Just d + _ -> Nothing + +-------------------------------------------------------------------------------- +-- Standard library patterns + +pattern VStandardLib :: StdLibFunction -> WHNFSpine builtin -> WHNFValue builtin +pattern VStandardLib fn spine <- VFreeVar (findStdLibFunction -> Just fn) spine + where + VStandardLib fn spine = VFreeVar (identifierOf fn) spine + +-------------------------------------------------------------------------------- +-- WHNFValue Function patterns + +pattern VBuiltinFunction :: (HasStandardData builtin) => BuiltinFunction -> WHNFSpine builtin -> WHNFValue builtin +pattern VBuiltinFunction f args <- VBuiltin (getBuiltinFunction -> Just f) args + where + VBuiltinFunction f args = VBuiltin (mkBuiltinFunction f) args + +pattern VOp1 :: (HasStandardData builtin) => BuiltinFunction -> WHNFValue builtin -> WHNFValue builtin +pattern VOp1 op x <- VBuiltinFunction op [RelevantExplicitArg _ x] + where + VOp1 op x = VBuiltinFunction op [Arg mempty Explicit Relevant x] + +pattern VOp2 :: (HasStandardData builtin) => BuiltinFunction -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VOp2 op x y <- VBuiltinFunction op [RelevantExplicitArg _ x, RelevantExplicitArg _ y] + where + VOp2 op x y = VBuiltinFunction op [Arg mempty Explicit Relevant x, Arg mempty Explicit Relevant y] + +pattern VAnd :: (HasStandardData builtin) => WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VAnd x y = VOp2 And x y + +pattern VOr :: (HasStandardData builtin) => WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VOr x y = VOp2 Or x y + +pattern VNot :: (HasStandardData builtin) => WHNFValue builtin -> WHNFValue builtin +pattern VNot x = VOp1 Not x + +pattern VIf :: (HasStandardData builtin) => WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VIf t c x y <- VBuiltinFunction If [RelevantImplicitArg _ t, RelevantExplicitArg _ c, RelevantExplicitArg _ x, RelevantExplicitArg _ y] + where + VIf t c x y = VBuiltinFunction If [Arg mempty (Implicit True) Relevant t, Arg mempty Explicit Relevant c, Arg mempty Explicit Relevant x, Arg mempty Explicit Relevant y] + +pattern VOrder :: (HasStandardData builtin) => OrderDomain -> OrderOp -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VOrder dom op x y = VOp2 (Order dom op) x y + +pattern VEqualOp :: (HasStandardData builtin) => EqualityDomain -> EqualityOp -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VEqualOp dom op x y = VOp2 (Equals dom op) x y + +pattern VEqual :: (HasStandardData builtin) => EqualityDomain -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VEqual dom x y = VEqualOp dom Eq x y + +pattern VNotEqual :: (HasStandardData builtin) => EqualityDomain -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VNotEqual dom x y = VEqualOp dom Neq x y + +pattern VNeg :: (HasStandardData builtin) => NegDomain -> WHNFValue builtin -> WHNFValue builtin +pattern VNeg dom x = VOp1 (Neg dom) x + +pattern VAdd :: (HasStandardData builtin) => AddDomain -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VAdd dom x y = VOp2 (Add dom) x y + +pattern VSub :: (HasStandardData builtin) => SubDomain -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VSub dom x y = VOp2 (Sub dom) x y + +pattern VMul :: (HasStandardData builtin) => MulDomain -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VMul dom x y = VOp2 (Mul dom) x y + +pattern VDiv :: (HasStandardData builtin) => DivDomain -> WHNFValue builtin -> WHNFValue builtin -> WHNFValue builtin +pattern VDiv dom x y = VOp2 (Div dom) x y diff --git a/vehicle/src/Vehicle/Data/BuiltinPatterns.hs b/vehicle/src/Vehicle/Data/BuiltinPatterns.hs deleted file mode 100644 index e43376041..000000000 --- a/vehicle/src/Vehicle/Data/BuiltinPatterns.hs +++ /dev/null @@ -1,107 +0,0 @@ -module Vehicle.Data.BuiltinPatterns where - -import Data.List.NonEmpty (NonEmpty (..)) -import Vehicle.Compile.Type.Subsystem.Standard.Core -import Vehicle.Syntax.AST - --------------------------------------------------------------------------------- --- Boolean operations - -pattern BuiltinFunctionExpr :: - Provenance -> - BuiltinFunction -> - NonEmpty (Arg var Builtin) -> - Expr var Builtin -pattern BuiltinFunctionExpr p b args = BuiltinExpr p (BuiltinFunction b) args - -pattern QuantifierExpr :: - Provenance -> - Quantifier -> - Binder var Builtin -> - Expr var Builtin -> - Expr var Builtin -pattern QuantifierExpr p q binder body <- - BuiltinFunctionExpr - p - (Quantifier q) - [ RelevantExplicitArg _ (Lam _ binder body) - ] - where - QuantifierExpr p q binder body = - BuiltinFunctionExpr - p - (Quantifier q) - [ Arg p Explicit Relevant (Lam p binder body) - ] - -pattern ExistsExpr :: - Provenance -> - Binder var Builtin -> - Expr var Builtin -> - Expr var Builtin -pattern ExistsExpr p binder body = - QuantifierExpr p Exists binder body - -pattern ForallExpr :: - Provenance -> - Binder var Builtin -> - Expr var Builtin -> - Expr var Builtin -pattern ForallExpr p binder body = - QuantifierExpr p Forall binder body - -pattern BooleanOp2Expr :: - BuiltinFunction -> - Provenance -> - NonEmpty (Arg var Builtin) -> - Expr var Builtin -pattern BooleanOp2Expr op p explicitArgs = BuiltinFunctionExpr p op explicitArgs - -pattern AndExpr :: Provenance -> NonEmpty (Arg var Builtin) -> Expr var Builtin -pattern AndExpr p explicitArgs = BooleanOp2Expr And p explicitArgs - -pattern OrExpr :: Provenance -> NonEmpty (Arg var Builtin) -> Expr var Builtin -pattern OrExpr p explicitArgs = BooleanOp2Expr Or p explicitArgs - -pattern ImpliesExpr :: Provenance -> NonEmpty (Arg var Builtin) -> Expr var Builtin -pattern ImpliesExpr p explicitArgs = BooleanOp2Expr Implies p explicitArgs - -pattern NotExpr :: Provenance -> NonEmpty (Arg var Builtin) -> Expr var Builtin -pattern NotExpr p explicitArgs = BuiltinFunctionExpr p Not explicitArgs - -pattern EqualityExpr :: - Provenance -> - EqualityDomain -> - EqualityOp -> - NonEmpty (Arg var Builtin) -> - Expr var Builtin -pattern EqualityExpr p dom op args = BuiltinFunctionExpr p (Equals dom op) args - -pattern OrderExpr :: - Provenance -> - OrderDomain -> - OrderOp -> - NonEmpty (Arg var Builtin) -> - Expr var Builtin -pattern OrderExpr p dom op args = BuiltinFunctionExpr p (Order dom op) args - -pattern IfExpr :: - Provenance -> - Expr var Builtin -> - [Arg var Builtin] -> - Expr var Builtin -pattern IfExpr p tRes args <- - BuiltinFunctionExpr - p - If - ( RelevantImplicitArg _ tRes - :| args - ) - where - IfExpr p tRes args = - BuiltinFunctionExpr - p - If - ( Arg p (Implicit True) Relevant tRes - :| args - ) diff --git a/vehicle/src/Vehicle/Data/Hashing.hs b/vehicle/src/Vehicle/Data/Hashing.hs index 310a6baf8..8255b53b6 100644 --- a/vehicle/src/Vehicle/Data/Hashing.hs +++ b/vehicle/src/Vehicle/Data/Hashing.hs @@ -12,7 +12,7 @@ import Vehicle.Syntax.AST -- but this proved to be unnecessary. It's still in the repo's history if -- need be though. -instance (Hashable builtin, Generic builtin) => Hashable (EnvValue 'WHNF builtin) +instance (Hashable builtin, Generic builtin) => Hashable (BoundEnvValue 'WHNF builtin) instance (Hashable builtin, Generic builtin) => Hashable (Body 'WHNF builtin) diff --git a/vehicle/src/Vehicle/Data/LinearExpr.hs b/vehicle/src/Vehicle/Data/LinearExpr.hs new file mode 100644 index 000000000..18f7d86b8 --- /dev/null +++ b/vehicle/src/Vehicle/Data/LinearExpr.hs @@ -0,0 +1,243 @@ +module Vehicle.Data.LinearExpr where + +import Control.Monad (foldM) +import Data.Aeson (FromJSON, FromJSONKey, ToJSON, ToJSONKey) +import Data.List.Split (chunksOf) +import Data.Map (Map) +import Data.Map qualified as Map +import Data.Maybe (fromMaybe) +import Data.Vector (Vector) +import Data.Vector qualified as Vector +import GHC.Generics (Generic) +import Vehicle.Prelude + +-------------------------------------------------------------------------------- +-- Coefficients + +-- At the moment we only support rational coefficients. +type Coefficient = Rational + +-------------------------------------------------------------------------------- +-- Constant interface + +-- If we're ever to support matrix multiplication we'll need to make this a full +-- field structure. +-- +-- However, we run into issues that we can't define a `zero` element as we don't +-- don't have access to the dimensions of tensors at the type level due to the +-- lack of dependent types. +class (Pretty constant) => IsConstant constant where + isZero :: constant -> Bool + scaleConstant :: Coefficient -> constant -> constant + addConstants :: Coefficient -> Coefficient -> constant -> constant -> constant + +-------------------------------------------------------------------------------- +-- Rational constants + +instance IsConstant Rational where + isZero = (== 0.0) + scaleConstant = (*) + addConstants a b x y = a * x + b * y + +-------------------------------------------------------------------------------- +-- Tensor constants + +data RationalTensor = RationalTensor + { tensorDims :: TensorDimensions, + tensorValues :: Vector Rational + } + deriving (Show, Eq, Ord, Generic) + +instance ToJSON RationalTensor + +instance FromJSON RationalTensor + +zeroTensor :: TensorDimensions -> RationalTensor +zeroTensor dims = RationalTensor dims (Vector.replicate (product dims) 0) + +mapTensor :: + (Rational -> Rational) -> + RationalTensor -> + RationalTensor +mapTensor f RationalTensor {..} = + RationalTensor + { tensorValues = Vector.map f tensorValues, + .. + } + +zipWithTensor :: + (Rational -> Rational -> Rational) -> + RationalTensor -> + RationalTensor -> + RationalTensor +zipWithTensor f t1 t2 = + RationalTensor + { tensorDims = tensorDims t1, + tensorValues = Vector.zipWith f (tensorValues t1) (tensorValues t2) + } + +instance Pretty RationalTensor where + pretty = foldTensor pretty prettyFlatList + +foldTensor :: forall a. (Rational -> a) -> ([a] -> a) -> RationalTensor -> a +foldTensor mkValue mkVec (RationalTensor dims value) = go dims (Vector.toList value) + where + go :: TensorDimensions -> [Rational] -> a + go [] xs = mkValue (head xs) + go (_d : ds) xs = do + let inputVarIndicesChunks = chunksOf (product ds) xs + let elems = fmap (go ds) inputVarIndicesChunks + mkVec elems + +instance IsConstant RationalTensor where + isZero = Vector.all (== 0) . tensorValues + scaleConstant v = mapTensor (scaleConstant v) + addConstants a b = zipWithTensor (addConstants a b) + +-------------------------------------------------------------------------------- +-- Sparse representations of linear expressions + +data LinearExpr variable constant = Sparse + { coefficients :: Map variable Coefficient, + constantValue :: constant + } + deriving (Show, Eq, Ord, Generic) + +instance (ToJSONKey variable, ToJSON constant) => ToJSON (LinearExpr variable constant) + +instance (Ord variable, FromJSONKey variable, FromJSON constant) => FromJSON (LinearExpr variable constant) + +constantExpr :: (Ord variable) => constant -> LinearExpr variable constant +constantExpr = Sparse mempty + +-- This is a bit annoying as we can't reconstruct `zero` purely from the type alone, +-- see comment on `IsConstant` type-class so we have to pass it explicitly. +singletonVarExpr :: constant -> variable -> LinearExpr variable constant +singletonVarExpr zero var = Sparse (Map.singleton var 1) zero + +prettyCoefficientVar :: + (Pretty variable) => + Bool -> + (variable, Coefficient) -> + Doc a +prettyCoefficientVar isFirst (variable, coefficient) = do + let sign + | coefficient > 0 = if isFirst then "" else "+ " + | otherwise = if isFirst then "-" else "- " + + let value + | coefficient == 1 = pretty variable + | coefficient == -1 = pretty variable + | coefficient > 0 = pretty coefficient <> pretty variable + | otherwise = pretty (-coefficient) <> pretty variable + + sign <> value + +-- | Pretty prints a constant value given a set of dimensions. +-- Note, an alternative would be to go via the Vehicle AST and pretty print +-- that, but we run into dependency cycle issues. +prettyConstant :: (IsConstant constant) => Bool -> constant -> Doc a +prettyConstant isFirst value + | not isFirst && isZero value = "" + | not isFirst = " + " <> pretty value + | otherwise = pretty value + +instance (Pretty variable, IsConstant constant) => Pretty (LinearExpr variable constant) where + pretty (Sparse coefficients constant) = do + -- Append an empty variable name for the constant at the end + let coeffVars = Map.toList coefficients + case coeffVars of + [] -> prettyConstant True constant + (x : xs) -> do + let varDocs = prettyCoefficientVar True x : fmap (prettyCoefficientVar False) xs + let constDoc = prettyConstant False constant + hsep varDocs <> constDoc + +addExprs :: + (Ord variable, IsConstant constant) => + Coefficient -> + Coefficient -> + LinearExpr variable constant -> + LinearExpr variable constant -> + LinearExpr variable constant +addExprs c1 c2 (Sparse coeff1 const1) (Sparse coeff2 const2) = do + -- We should really be able to do this in one operation, but the API isn't flexible enough. + let coeff1' = if c1 == 1 then coeff1 else Map.map (c1 *) coeff1 + let coeff2' = if c2 == 1 then coeff2 else Map.map (c2 *) coeff2 + let rcoeff = Map.filter (/= 0) (Map.unionWith (+) coeff1' coeff2') + let rconst = addConstants c1 c2 const1 const2 + Sparse rcoeff rconst + +scaleExpr :: (IsConstant constant) => Coefficient -> LinearExpr variable constant -> LinearExpr variable constant +scaleExpr c (Sparse coefficients constant) = + Sparse (Map.map (c *) coefficients) (scaleConstant c constant) + +lookupCoefficient :: (Ord variable) => LinearExpr variable constant -> variable -> Coefficient +lookupCoefficient (Sparse coefficients _) v = fromMaybe 0 $ Map.lookup v coefficients + +referencesVariable :: (Ord variable) => LinearExpr variable constant -> variable -> Bool +referencesVariable (Sparse coefficients _) v = v `Map.member` coefficients + +isConstant :: LinearExpr variable constant -> Maybe constant +isConstant (Sparse coeff constant) + | Map.null coeff = Just constant + | otherwise = Nothing + +evaluateExpr :: + forall variable constant. + (Ord variable, IsConstant constant) => + LinearExpr variable constant -> + Map variable constant -> + Either variable constant +evaluateExpr expr assignment = do + let Sparse coefficients constant = expr + foldM op constant (Map.toList coefficients) + where + op :: constant -> (variable, Coefficient) -> Either variable constant + op total (var, coeff) = case Map.lookup var assignment of + Nothing -> Left var + Just value -> Right (addConstants 1 coeff total value) + +eliminateVar :: + (Ord variable, IsConstant constant) => + variable -> + LinearExpr variable constant -> + LinearExpr variable constant -> + LinearExpr variable constant +eliminateVar var solution row = do + let varCoefficient = lookupCoefficient row var + if varCoefficient == 0 + then row + else do + let scaleFactor = varCoefficient / lookupCoefficient solution var + let resultExpr = addExprs 1 (-scaleFactor) row solution + let newCoefficients = Map.delete var $ coefficients resultExpr + -- Need to handle floating point errors.... + resultExpr + { coefficients = newCoefficients + } + +-- | Takes an assertion `a*x_0 + ... + b*x_i + ... c * x_n` and +-- returns the RHS of the equation: `x_i = -a/b*x_0 + ... -c/b*x_n` +rearrangeExprToSolveFor :: + (Ord variable, IsConstant constant) => + variable -> + LinearExpr variable constant -> + LinearExpr variable constant +rearrangeExprToSolveFor var expr = do + let c = lookupCoefficient expr var + let scaledExpr = scaleExpr (-1 / c) expr + scaledExpr + { coefficients = Map.delete var $ coefficients scaledExpr + } + +mapExprVariables :: + (Ord variable1, Ord variable2) => + (variable1 -> variable2) -> + LinearExpr variable1 constant -> + LinearExpr variable2 constant +mapExprVariables f Sparse {..} = + Sparse + { coefficients = Map.mapKeys f coefficients, + .. + } diff --git a/vehicle/src/Vehicle/Data/NormalisedExpr.hs b/vehicle/src/Vehicle/Data/NormalisedExpr.hs index ddf9a7628..e5eeb1ac1 100644 --- a/vehicle/src/Vehicle/Data/NormalisedExpr.hs +++ b/vehicle/src/Vehicle/Data/NormalisedExpr.hs @@ -18,7 +18,7 @@ data NFStrategy = NF | WHNF data Body :: NFStrategy -> Kind.Type -> Kind.Type where NFBody :: Value 'NF builtin -> Body 'NF builtin - WHNFBody :: Env 'WHNF builtin -> Expr Ix builtin -> Body 'WHNF builtin + WHNFBody :: BoundEnv 'WHNF builtin -> Expr Ix builtin -> Body 'WHNF builtin deriving instance (Eq builtin) => Eq (Body stategy builtin) @@ -29,7 +29,7 @@ deriving instance (Show builtin) => Show (Body stategy builtin) instance (Generic builtin) => Generic (Body 'WHNF builtin) where type Rep (Body 'WHNF builtin) = - Rep (Env 'WHNF builtin) + Rep (BoundEnv 'WHNF builtin) :*: Rep (Expr Ix builtin) to (u :*: v) = WHNFBody (to u) (to v) @@ -55,10 +55,10 @@ type VBinder strategy builtin = GenericBinder (Value strategy builtin) type Spine strategy builtin = [VArg strategy builtin] ----------------------------------------------------------------------------- --- Environments +-- Bound environments -- | Represents a variable's value in the environment. -data EnvValue strategy builtin +data BoundEnvValue strategy builtin = -- | The variable has no known concrete value. Bound | -- | The variable has a known value. @@ -68,43 +68,43 @@ data EnvValue strategy builtin -- | The information stored for each variable in the environment. We choose -- to store the binder as it's a convenient mechanism for passing through -- name, relevance for pretty printing and debugging. -type EnvEntry strategy builtin = (GenericBinder (), EnvValue strategy builtin) +type EnvEntry strategy builtin = (GenericBinder (), BoundEnvValue strategy builtin) isBoundEntry :: EnvEntry strategy builtin -> Bool isBoundEntry (_binder, value) = case value of Bound {} -> True Defined {} -> False -type Env strategy builtin = GenericBoundCtx (EnvEntry strategy builtin) +type BoundEnv strategy builtin = GenericBoundCtx (EnvEntry strategy builtin) -emptyEnv :: Env strategy builtin -emptyEnv = mempty +emptyBoundEnv :: BoundEnv strategy builtin +emptyBoundEnv = mempty -mkDefaultEnvEntry :: Name -> EnvValue strategy builtin -> EnvEntry strategy builtin +mkDefaultEnvEntry :: Name -> BoundEnvValue strategy builtin -> EnvEntry strategy builtin mkDefaultEnvEntry name value = (Binder mempty displayForm Explicit Relevant (), value) where displayForm = BinderDisplayForm (OnlyName name) True extendEnvWithBound :: GenericBinder expr -> - Env strategy builtin -> - Env strategy builtin + BoundEnv strategy builtin -> + BoundEnv strategy builtin extendEnvWithBound binder env = (void binder, Bound) : env extendEnvWithDefined :: Value strategy builtin -> GenericBinder expr -> - Env strategy builtin -> - Env strategy builtin + BoundEnv strategy builtin -> + BoundEnv strategy builtin extendEnvWithDefined value binder env = (void binder, Defined value) : env boundContextToEnv :: BoundCtx builtin -> - Env strategy builtin + BoundEnv strategy builtin boundContextToEnv = fmap (\binder -> (void binder, Bound)) -- | Converts an environment to set of values suitable for printing -cheatEnvToValues :: Env strategy builtin -> GenericBoundCtx (Value strategy builtin) +cheatEnvToValues :: BoundEnv strategy builtin -> GenericBoundCtx (Value strategy builtin) cheatEnvToValues = fmap envEntryToValue where envEntryToValue :: EnvEntry strategy builtin -> Value strategy builtin @@ -121,8 +121,6 @@ cheatEnvToValues = fmap envEntryToValue type WHNFValue builtin = Value 'WHNF builtin -type WHNFEnv builtin = Env 'WHNF builtin - type WHNFType builtin = WHNFValue builtin type WHNFArg builtin = VArg 'WHNF builtin @@ -131,12 +129,16 @@ type WHNFBinder builtin = VBinder 'WHNF builtin type WHNFSpine builtin = Spine 'WHNF builtin +type WHNFDecl builtin = GenericDecl (WHNFValue builtin) + +type WHNFBoundEnv builtin = BoundEnv 'WHNF builtin + ----------------------------------------------------------------------------- -- NF type NFValue builtin = Value 'NF builtin -type NFEnv builtin = Env 'NF builtin +type NFEnv builtin = BoundEnv 'NF builtin type NFType builtin = NFValue builtin diff --git a/vehicle/src/Vehicle/Export.hs b/vehicle/src/Vehicle/Export.hs index c3ae73a44..77aac50e8 100644 --- a/vehicle/src/Vehicle/Export.hs +++ b/vehicle/src/Vehicle/Export.hs @@ -3,6 +3,7 @@ module Vehicle.Export where import Control.Monad.IO.Class (MonadIO (..)) import Vehicle.Backend.Prelude import Vehicle.Compile +import Vehicle.Prelude.IO (MonadStdIO) import Vehicle.Prelude.Logging import Vehicle.Resource import Vehicle.Verify.Specification (SpecificationCacheIndex (..)) @@ -16,7 +17,7 @@ data ExportOptions = ExportOptions } deriving (Eq, Show) -export :: LoggingSettings -> ExportOptions -> IO () +export :: (MonadStdIO IO) => LoggingSettings -> ExportOptions -> IO () export loggingSettings ExportOptions {..} = do let cacheIndexFile = specificationCacheIndexFileName verificationCache SpecificationCacheIndex {..} <- liftIO $ readSpecificationCacheIndex cacheIndexFile diff --git a/vehicle/src/Vehicle/Libraries/StandardLibrary/Definitions.hs b/vehicle/src/Vehicle/Libraries/StandardLibrary/Definitions.hs index eba3a8cec..d24f97c72 100644 --- a/vehicle/src/Vehicle/Libraries/StandardLibrary/Definitions.hs +++ b/vehicle/src/Vehicle/Libraries/StandardLibrary/Definitions.hs @@ -1,9 +1,11 @@ module Vehicle.Libraries.StandardLibrary.Definitions where +import Data.Hashable (Hashable) import Data.Map (Map) import Data.Map qualified as Map import Data.Maybe (isJust) import Data.Text (pack) +import GHC.Generics (Generic) import Vehicle.Prelude import Vehicle.Syntax.AST import Vehicle.Syntax.Builtin @@ -12,7 +14,8 @@ pattern TensorIdent :: Identifier pattern TensorIdent = Identifier StdLib "Tensor" data StdLibFunction - = StdBigAnd + = StdNotBoolOp2 + | StdBigAnd | StdBigOr | StdExistsIndex | StdForallIndex @@ -28,10 +31,11 @@ data StdLibFunction | StdVectorToList | StdForeach | StdTensor - deriving (Eq, Ord, Enum, Bounded) + deriving (Eq, Ord, Enum, Bounded, Generic) instance Show StdLibFunction where show = \case + StdNotBoolOp2 -> "notBoolOp2" StdBigAnd -> "bigAnd" StdBigOr -> "bigOr" StdExistsIndex -> "existsIndex" @@ -52,6 +56,8 @@ instance Show StdLibFunction where instance Pretty StdLibFunction where pretty = pretty . show +instance Hashable StdLibFunction + instance HasIdentifier StdLibFunction where identifierOf f = Identifier StdLib $ pack $ show f diff --git a/vehicle/src/Vehicle/Prelude/IO.hs b/vehicle/src/Vehicle/Prelude/IO.hs index bbe579ce5..f4ead2bf6 100644 --- a/vehicle/src/Vehicle/Prelude/IO.hs +++ b/vehicle/src/Vehicle/Prelude/IO.hs @@ -10,13 +10,21 @@ module Vehicle.Prelude.IO programOutput, getVehiclePath, ExternalOutputFormat (..), + MonadStdIO (..), ) where import Control.Exception (catch, throwIO) -- import Control.Monad (forM_) +import Control.Monad.Except (ExceptT) import Control.Monad.IO.Class (MonadIO (..)) +import Control.Monad.Identity (IdentityT) +import Control.Monad.Reader (ReaderT) +import Control.Monad.State (StateT) +import Control.Monad.Trans.Class (MonadTrans (lift)) +import Control.Monad.Writer (WriterT) +import Data.Text (Text) import Data.Version (Version) import Prettyprinter (Doc) import System.Directory (createDirectoryIfMissing, removeFile) @@ -27,6 +35,57 @@ import System.IO (hPrint, stderr) import System.IO.Error (isDoesNotExistError) import System.Info (os) +-------------------------------------------------------------------------------- +-- Streams + +class (MonadIO m) => MonadStdIO m where + writeStdout :: Text -> m () + writeStderr :: Text -> m () + + writeStdoutLn :: Text -> m () + writeStdoutLn = writeStdout . (<> "\n") + + writeStderrLn :: Text -> m () + writeStderrLn = writeStderr . (<> "\n") + +{-# SPECIALIZE writeStdout :: Text -> IO () #-} + +{-# SPECIALIZE writeStdoutLn :: Text -> IO () #-} + +{-# SPECIALIZE writeStderr :: Text -> IO () #-} + +{-# SPECIALIZE writeStderrLn :: Text -> IO () #-} + +instance (MonadStdIO m) => MonadStdIO (StateT s m) where + writeStdout :: (MonadStdIO m) => Text -> StateT s m () + writeStdout = lift . writeStdout + writeStderr :: (MonadStdIO m) => Text -> StateT s m () + writeStderr = lift . writeStderr + +instance (MonadStdIO m) => MonadStdIO (ReaderT s m) where + writeStdout :: (MonadStdIO m) => Text -> ReaderT s m () + writeStdout = lift . writeStdout + writeStderr :: (MonadStdIO m) => Text -> ReaderT s m () + writeStderr = lift . writeStderr + +instance (Monoid w, MonadStdIO m) => MonadStdIO (WriterT w m) where + writeStdout :: (Monoid w, MonadStdIO m) => Text -> WriterT w m () + writeStdout = lift . writeStdout + writeStderr :: (Monoid w, MonadStdIO m) => Text -> WriterT w m () + writeStderr = lift . writeStderr + +instance (MonadStdIO m) => MonadStdIO (IdentityT m) where + writeStdout = lift . writeStdout + writeStderr = lift . writeStderr + writeStdoutLn = lift . writeStdoutLn + writeStderrLn = lift . writeStderrLn + +instance (MonadStdIO m) => MonadStdIO (ExceptT e m) where + writeStdout :: (MonadStdIO m) => Text -> ExceptT e m () + writeStdout = lift . writeStdout + writeStderr :: (MonadStdIO m) => Text -> ExceptT e m () + writeStderr = lift . writeStderr + -------------------------------------------------------------------------------- -- Files diff --git a/vehicle/src/Vehicle/Prelude/Logging.hs b/vehicle/src/Vehicle/Prelude/Logging.hs index e600e8432..6d0985b26 100644 --- a/vehicle/src/Vehicle/Prelude/Logging.hs +++ b/vehicle/src/Vehicle/Prelude/Logging.hs @@ -1,9 +1,7 @@ module Vehicle.Prelude.Logging ( module X, - showMessages, ) where -import Vehicle.Prelude.Logging.Backend (showMessages) import Vehicle.Prelude.Logging.Class as X import Vehicle.Prelude.Logging.Instance as X diff --git a/vehicle/src/Vehicle/Prelude/Logging/Backend.hs b/vehicle/src/Vehicle/Prelude/Logging/Backend.hs index 892f7e9b6..8a6e4e442 100644 --- a/vehicle/src/Vehicle/Prelude/Logging/Backend.hs +++ b/vehicle/src/Vehicle/Prelude/Logging/Backend.hs @@ -8,54 +8,45 @@ module Vehicle.Prelude.Logging.Backend runSilentBackendT, DelayedBackendT, runDelayedBackendT, - showMessages, ) where -import Control.Monad (unless) -import Control.Monad.Except (MonadError (..)) +import Control.Monad.Identity (IdentityT (..)) +import Control.Monad.RWS (RWST) import Control.Monad.Reader (ReaderT (..), ask) -import Control.Monad.State (MonadState (..), StateT (..), evalStateT) +import Control.Monad.State (StateT (..), evalStateT) import Control.Monad.Trans (MonadIO (..), MonadTrans (..)) import Control.Monad.Writer (MonadWriter (..), WriterT (..)) import Data.IntSet (IntSet) -import Data.IntSet qualified as IntSet -import Data.Text qualified as Text (unpack) -import Prettyprinter (Pretty (..), line, (<+>)) -import System.Console.ANSI -import System.IO (Handle, hPutStrLn) +import Data.Text (Text) +import Data.Text qualified as Text (pack) import Vehicle.Compile.Print.Warning () +import Vehicle.Prelude.IO as VIO (MonadStdIO (..)) import Vehicle.Prelude.Logging.Class -import Vehicle.Prelude.Misc (setTextColour) -import Vehicle.Prelude.Warning -import Vehicle.Syntax.Prelude -------------------------------------------------------------------------------- -- Class for logging backends class (Monad m) => MonadLoggingBackend m where - output :: Message -> m () + logDebugMessage :: DebugMessage -> m () -instance (MonadLoggingBackend m) => MonadLoggingBackend (StateT s m) where - output = lift . output - -instance (MonadLoggingBackend m) => MonadLoggingBackend (ReaderT s m) where - output = lift . output +instance (MonadLoggingBackend m, Monoid w) => MonadLoggingBackend (RWST r w s m) where + logDebugMessage = lift . logDebugMessage -------------------------------------------------------------------------------- -- Immediate backend +type LogAction = Text -> IO () + newtype ImmediateBackendT m a = ImmediateBackendT - { unImmediateBackendT :: StateT IntSet (ReaderT Handle m) a + { unImmediateBackendT :: StateT IntSet (ReaderT LogAction m) a } deriving (Functor, Applicative, Monad) instance (MonadIO m) => MonadLoggingBackend (ImmediateBackendT m) where - output message = ImmediateBackendT $ do - handle <- ask - isDuplicateWarning <- isAlreadySeenWarning message - unless isDuplicateWarning $ do - lift $ liftIO $ hPutStrLn handle (showMessage message) + logDebugMessage message = ImmediateBackendT $ do + logAction <- ask + lift $ liftIO $ logAction (Text.pack $ show message) instance MonadTrans ImmediateBackendT where lift = ImmediateBackendT . lift . lift @@ -63,47 +54,37 @@ instance MonadTrans ImmediateBackendT where instance (MonadIO m) => MonadIO (ImmediateBackendT m) where liftIO = lift . liftIO -runImmediateBackendT :: (MonadIO m) => Handle -> ImmediateBackendT m a -> m a -runImmediateBackendT logHandle v = - runReaderT (evalStateT (unImmediateBackendT v) mempty) logHandle +instance (MonadStdIO m) => MonadStdIO (ImmediateBackendT m) where + writeStdout = lift . VIO.writeStdout + writeStderr = lift . VIO.writeStderr + writeStdoutLn = lift . VIO.writeStdoutLn + writeStderrLn = lift . VIO.writeStderrLn + +runImmediateBackendT :: (MonadIO m) => (Text -> IO ()) -> ImmediateBackendT m a -> m a +runImmediateBackendT putLogLn v = + runReaderT (evalStateT (unImmediateBackendT v) mempty) putLogLn -------------------------------------------------------------------------------- -- Silent backend -newtype SilentBackendT m a = SilentBackendT - { unSilentBackendT :: m a - } - deriving (Functor, Applicative, Monad) +type SilentBackendT = IdentityT instance (Monad m) => MonadLoggingBackend (SilentBackendT m) where - output _message = return () - -instance MonadTrans SilentBackendT where - lift = SilentBackendT - -instance (MonadIO m) => MonadIO (SilentBackendT m) where - liftIO = lift . liftIO - -instance (MonadError e m) => MonadError e (SilentBackendT m) where - throwError = lift . throwError - catchError m f = SilentBackendT (catchError (unSilentBackendT m) (unSilentBackendT . f)) + logDebugMessage _message = return () runSilentBackendT :: SilentBackendT m a -> m a -runSilentBackendT = unSilentBackendT +runSilentBackendT = runIdentityT -------------------------------------------------------------------------------- -- Delayed backend newtype DelayedBackendT m a = DelayedBackendT - { unDelayedBackendT :: StateT IntSet (WriterT [Message] m) a + { unDelayedBackendT :: StateT IntSet (WriterT [DebugMessage] m) a } deriving (Functor, Applicative, Monad) instance (Monad m) => MonadLoggingBackend (DelayedBackendT m) where - output message = DelayedBackendT $ do - isDuplicateWarning <- isAlreadySeenWarning message - unless isDuplicateWarning $ do - tell [message] + logDebugMessage message = DelayedBackendT $ tell [message] instance MonadTrans DelayedBackendT where lift = DelayedBackendT . lift . lift @@ -111,35 +92,11 @@ instance MonadTrans DelayedBackendT where instance (MonadIO m) => MonadIO (DelayedBackendT m) where liftIO = lift . liftIO -runDelayedBackendT :: (Monad m) => DelayedBackendT m a -> m (a, [Message]) -runDelayedBackendT v = runWriterT (evalStateT (unDelayedBackendT v) mempty) - --------------------------------------------------------------------------------- --- Duplicate detection - -isAlreadySeenWarning :: (MonadState IntSet m) => Message -> m Bool -isAlreadySeenWarning = \case - DebugMessage {} -> return False - WarningMessage w -> do - case warningDuplicateDetectionHash w of - Nothing -> return False - Just value -> do - seenWarnings <- get - if value `IntSet.member` seenWarnings - then return True - else do - put (IntSet.insert value seenWarnings) - return False - --------------------------------------------------------------------------------- --- Formatting - -showMessage :: Message -> String -showMessage = \case - DebugMessage t -> - setTextColour Green $ Text.unpack t - WarningMessage w -> - setTextColour Yellow $ layoutAsString (line <> "Warning: " <+> pretty w <> line) +instance (MonadStdIO m) => MonadStdIO (DelayedBackendT m) where + writeStdout = lift . VIO.writeStdout + writeStderr = lift . VIO.writeStderr + writeStdoutLn = lift . VIO.writeStdoutLn + writeStderrLn = lift . VIO.writeStderrLn -showMessages :: [Message] -> String -showMessages logs = unlines $ map showMessage logs +runDelayedBackendT :: (Monad m) => DelayedBackendT m a -> m (a, [DebugMessage]) +runDelayedBackendT v = runWriterT (evalStateT (unDelayedBackendT v) mempty) diff --git a/vehicle/src/Vehicle/Prelude/Logging/Class.hs b/vehicle/src/Vehicle/Prelude/Logging/Class.hs index 0c33956ee..7c8084b0a 100644 --- a/vehicle/src/Vehicle/Prelude/Logging/Class.hs +++ b/vehicle/src/Vehicle/Prelude/Logging/Class.hs @@ -1,10 +1,9 @@ module Vehicle.Prelude.Logging.Class ( CompilerPass, LoggingLevel (..), - Message (..), + DebugMessage, MonadLogger (..), defaultLoggingLevel, - logWarning, logDebug, logDebugM, allLoggingLevels, @@ -17,12 +16,15 @@ where import Control.Monad (when) import Control.Monad.Except (ExceptT (..)) +import Control.Monad.Identity (IdentityT) import Control.Monad.Reader (ReaderT (..)) import Control.Monad.State (StateT (..)) import Control.Monad.Trans (MonadTrans (..)) import Control.Monad.Writer (WriterT (..)) import Data.Text (Text) -import Vehicle.Prelude.Misc (enumerate, supportedOptions) +import Data.Text qualified as Text (unpack) +import System.Console.ANSI (Color (..)) +import Vehicle.Prelude.Misc (enumerate, setTextColour, supportedOptions) import Vehicle.Prelude.Prettyprinter import Vehicle.Prelude.Supply (SupplyT) import Vehicle.Prelude.Warning @@ -57,9 +59,10 @@ loggingLevelHelp = -------------------------------------------------------------------------------- -- Messages -data Message - = DebugMessage Text - | WarningMessage CompileWarning +newtype DebugMessage = DebugMessage Text + +instance Show DebugMessage where + show (DebugMessage t) = setTextColour Green $ Text.unpack t type CallDepth = Int @@ -72,7 +75,8 @@ class (Monad m) => MonadLogger m where incrCallDepth :: m () decrCallDepth :: m () getDebugLevel :: m LoggingLevel - logMessage :: Message -> m () + logMessage :: DebugMessage -> m () + logWarning :: CompileWarning -> m () instance (MonadLogger m) => MonadLogger (StateT s m) where setCallDepth = lift . setCallDepth @@ -81,6 +85,7 @@ instance (MonadLogger m) => MonadLogger (StateT s m) where decrCallDepth = lift decrCallDepth getDebugLevel = lift getDebugLevel logMessage = lift . logMessage + logWarning = lift . logWarning instance (MonadLogger m) => MonadLogger (ReaderT s m) where setCallDepth = lift . setCallDepth @@ -89,6 +94,7 @@ instance (MonadLogger m) => MonadLogger (ReaderT s m) where decrCallDepth = lift decrCallDepth getDebugLevel = lift getDebugLevel logMessage = lift . logMessage + logWarning = lift . logWarning instance (Monoid w, MonadLogger m) => MonadLogger (WriterT w m) where setCallDepth = lift . setCallDepth @@ -97,6 +103,7 @@ instance (Monoid w, MonadLogger m) => MonadLogger (WriterT w m) where decrCallDepth = lift decrCallDepth getDebugLevel = lift getDebugLevel logMessage = lift . logMessage + logWarning = lift . logWarning instance (MonadLogger m) => MonadLogger (ExceptT e m) where setCallDepth = lift . setCallDepth @@ -105,6 +112,7 @@ instance (MonadLogger m) => MonadLogger (ExceptT e m) where decrCallDepth = lift decrCallDepth getDebugLevel = lift getDebugLevel logMessage = lift . logMessage + logWarning = lift . logWarning instance (MonadLogger m) => MonadLogger (SupplyT s m) where setCallDepth = lift . setCallDepth @@ -113,9 +121,16 @@ instance (MonadLogger m) => MonadLogger (SupplyT s m) where decrCallDepth = lift decrCallDepth getDebugLevel = lift getDebugLevel logMessage = lift . logMessage + logWarning = lift . logWarning -logWarning :: (MonadLogger m) => CompileWarning -> m () -logWarning warning = logMessage $ WarningMessage warning +instance (MonadLogger m) => MonadLogger (IdentityT m) where + setCallDepth = lift . setCallDepth + getCallDepth = lift getCallDepth + incrCallDepth = lift incrCallDepth + decrCallDepth = lift decrCallDepth + getDebugLevel = lift getDebugLevel + logMessage = lift . logMessage + logWarning = lift . logWarning logDebugM :: (MonadLogger m) => LoggingLevel -> m (Doc a) -> m () logDebugM level getText = do diff --git a/vehicle/src/Vehicle/Prelude/Logging/Instance.hs b/vehicle/src/Vehicle/Prelude/Logging/Instance.hs index e99f76b4a..9b05d2cb3 100644 --- a/vehicle/src/Vehicle/Prelude/Logging/Instance.hs +++ b/vehicle/src/Vehicle/Prelude/Logging/Instance.hs @@ -4,34 +4,39 @@ module Vehicle.Prelude.Logging.Instance ( LoggerT (..), LoggingSettings (..), ImmediateLoggerT, - ImmediateLogger, runImmediateLoggerT, - runImmediateLogger, SilentLoggerT, SilentLogger, runSilentLoggerT, - runSilentLogger, DelayedLoggerT, DelayedLogger, runDelayedLoggerT, - runDelayedLogger, + showCompileWarnings, ) where +import Control.Monad (unless) import Control.Monad.Except (MonadError (..)) import Control.Monad.Identity (Identity (..)) -import Control.Monad.Reader (ReaderT (..), ask) -import Control.Monad.State (MonadState (..), StateT (..), evalStateT, modify) +import Control.Monad.RWS (RWST (..)) +import Control.Monad.Reader (ask) +import Control.Monad.State (MonadState (..), modify) import Control.Monad.Trans (MonadIO (..), MonadTrans (..)) -import System.IO (Handle) +import Control.Monad.Writer (MonadWriter (..)) +import Data.Text (Text, pack) +import System.Console.ANSI (Color (..)) +import Vehicle.Compile.Print.Warning () +import Vehicle.Prelude +import Vehicle.Prelude.IO as VIO (MonadStdIO (..)) import Vehicle.Prelude.Logging.Backend import Vehicle.Prelude.Logging.Class +import Vehicle.Prelude.Warning -------------------------------------------------------------------------------- -- Settings data LoggingSettings = LoggingSettings - { logHandle :: Handle, + { putLogLn :: Text -> IO (), loggingLevel :: LoggingLevel } @@ -39,13 +44,14 @@ data LoggingSettings = LoggingSettings -- Logging monad instance newtype LoggerT m a = LoggerT - { unloggerT :: ReaderT LoggingLevel (StateT Int m) a + { unloggerT :: RWST LoggingLevel [CompileWarning] Int m a } deriving (Functor, Applicative, Monad) -runLoggerT :: (Monad m) => LoggingLevel -> LoggerT m a -> m a -runLoggerT debugLevel (LoggerT logger) = - evalStateT (runReaderT logger debugLevel) 0 +runLoggerT :: (Monad m) => LoggingLevel -> LoggerT m a -> m (a, [SummarisedCompileWarning]) +runLoggerT debugLevel (LoggerT logger) = do + (result, _, warnings) <- runRWST logger debugLevel 0 + return (result, groupWarnings warnings) instance (Monad m, MonadLoggingBackend m) => MonadLogger (LoggerT m) where setCallDepth = LoggerT . put @@ -53,10 +59,11 @@ instance (Monad m, MonadLoggingBackend m) => MonadLogger (LoggerT m) where incrCallDepth = LoggerT $ modify (+ 1) decrCallDepth = LoggerT $ modify (\x -> x - 1) getDebugLevel = LoggerT ask - logMessage m = LoggerT $ output m + logMessage m = LoggerT $ logDebugMessage m + logWarning m = LoggerT $ tell [m] instance MonadTrans LoggerT where - lift = LoggerT . lift . lift + lift = LoggerT . lift instance (MonadError e m) => MonadError e (LoggerT m) where throwError = lift . throwError @@ -65,21 +72,27 @@ instance (MonadError e m) => MonadError e (LoggerT m) where instance (MonadIO m) => MonadIO (LoggerT m) where liftIO = lift . liftIO +instance (MonadStdIO m) => MonadStdIO (LoggerT m) where + writeStdout = lift . VIO.writeStdout + writeStderr = lift . VIO.writeStderr + writeStdoutLn = lift . VIO.writeStdoutLn + writeStderrLn = lift . VIO.writeStderrLn + -------------------------------------------------------------------------------- -- Immediate logging -- | Immediately prints the logged messages to the output handle. type ImmediateLoggerT m = LoggerT (ImmediateBackendT m) -type ImmediateLogger = ImmediateLoggerT IO - runImmediateLoggerT :: (MonadIO m) => LoggingSettings -> ImmediateLoggerT m a -> m a -runImmediateLoggerT LoggingSettings {..} value = - runImmediateBackendT logHandle (runLoggerT loggingLevel value) - -runImmediateLogger :: (MonadIO m) => LoggingSettings -> ImmediateLoggerT m a -> m a -runImmediateLogger LoggingSettings {..} value = - runImmediateBackendT logHandle (runLoggerT loggingLevel value) +runImmediateLoggerT LoggingSettings {..} value = do + (result, warnings) <- runImmediateBackendT putLogLn (runLoggerT loggingLevel value) + unless (null warnings) $ + liftIO $ + putLogLn $ + pack $ + showCompileWarnings warnings + return result -------------------------------------------------------------------------------- -- Silent logging @@ -90,10 +103,7 @@ type SilentLoggerT m = LoggerT (SilentBackendT m) type SilentLogger = SilentLoggerT Identity runSilentLoggerT :: (Monad m) => SilentLoggerT m a -> m a -runSilentLoggerT value = runSilentBackendT (runLoggerT NoDetail value) - -runSilentLogger :: SilentLogger a -> a -runSilentLogger value = runIdentity $ runSilentLoggerT value +runSilentLoggerT value = fst <$> runSilentBackendT (runLoggerT NoDetail value) -------------------------------------------------------------------------------- -- Delayed logging @@ -103,8 +113,16 @@ type DelayedLoggerT m = LoggerT (DelayedBackendT m) type DelayedLogger = DelayedLoggerT Identity -runDelayedLoggerT :: (Monad m) => LoggingLevel -> DelayedLoggerT m a -> m (a, [Message]) -runDelayedLoggerT debugLevel = runDelayedBackendT . runLoggerT debugLevel +runDelayedLoggerT :: (Monad m) => LoggingLevel -> DelayedLoggerT m a -> m (a, [DebugMessage], [SummarisedCompileWarning]) +runDelayedLoggerT loggingLevel value = do + ((a, w), m) <- runDelayedBackendT (runLoggerT loggingLevel value) + return (a, m, w) + +-------------------------------------------------------------------------------- +-- Showing warnings -runDelayedLogger :: LoggingLevel -> DelayedLogger a -> (a, [Message]) -runDelayedLogger debugLevel = runIdentity . runDelayedBackendT . runLoggerT debugLevel +showCompileWarnings :: [SummarisedCompileWarning] -> String +showCompileWarnings ws = + setTextColour Yellow $ + layoutAsString $ + vsep (fmap (\w -> line <> "Warning: " <+> pretty w <> line) ws) diff --git a/vehicle/src/Vehicle/Prelude/Misc.hs b/vehicle/src/Vehicle/Prelude/Misc.hs index a723ea2d0..235a931f9 100644 --- a/vehicle/src/Vehicle/Prelude/Misc.hs +++ b/vehicle/src/Vehicle/Prelude/Misc.hs @@ -19,9 +19,10 @@ import Data.Text qualified as Text import GHC.Generics (Generic) import Numeric (readFloat, readSigned) import System.Console.ANSI -import Vehicle.Prelude.Prettyprinter (Pretty (pretty)) +import Vehicle.Prelude.Prettyprinter (Pretty (pretty), (<+>)) import Vehicle.Syntax.AST import Vehicle.Syntax.Builtin +import Vehicle.Syntax.Prelude (developerError) data VehicleLang = External | Internal deriving (Show) @@ -29,9 +30,6 @@ data VehicleLang = External | Internal -- | A textual representation of a Vehicle specification. type SpecificationText = Text --- | A set of properties in the specification. -type PropertyNames = [Name] - -- | A set of declarations in the specification. type DeclarationNames = [Name] @@ -215,6 +213,14 @@ type TensorDimensions = [Int] type TensorIndices = [Int] +computeFlatIndex :: TensorDimensions -> TensorIndices -> Int +computeFlatIndex = go + where + go :: TensorDimensions -> TensorIndices -> Int + go [] [] = 0 + go (d : ds) (i : is) | i < d = i * product ds + go ds is + go ds is = developerError $ "Invalid flat tensor arguments" <+> pretty ds <+> pretty is + showTensorIndices :: TensorIndices -> String showTensorIndices xs = concatMap (\v -> "!" <> show v) (reverse xs) @@ -228,3 +234,10 @@ setTextColour :: Color -> String -> String setTextColour c s = join [setSGRCode [SetColor Foreground Vivid c], s, setSGRCode []] + +cartesianProduct :: (a -> b -> c) -> [a] -> [b] -> [c] +cartesianProduct f xs ys = [f x y | x <- xs, y <- ys] + +thenCmp :: Ordering -> Ordering -> Ordering +thenCmp EQ o2 = o2 +thenCmp o1 _ = o1 diff --git a/vehicle/src/Vehicle/Prelude/Prettyprinter.hs b/vehicle/src/Vehicle/Prelude/Prettyprinter.hs index ce790bd29..055fb7d10 100644 --- a/vehicle/src/Vehicle/Prelude/Prettyprinter.hs +++ b/vehicle/src/Vehicle/Prelude/Prettyprinter.hs @@ -10,12 +10,15 @@ import Data.IntMap (IntMap) import Data.IntMap qualified as IntMap (toAscList) import Data.IntSet (IntSet) import Data.IntSet qualified as IntSet (toAscList) +-- This stuff we re-export + +import Data.List.NonEmpty (NonEmpty) +import Data.List.NonEmpty qualified as NonEmpty import Data.Map (Map) import Data.Map qualified as Map (toAscList) import Data.Set (Set) import Data.Set qualified as Set import Data.Version (Version, showVersion) --- This stuff we re-export import Data.Void (Void) import Prettyprinter (group, line', surround, unAnnotate) import Prettyprinter as CommonPrettyprinter @@ -69,6 +72,11 @@ numberedList elems = vsep (zipWith (\i e -> pretty i <> "." <+> e) [(1 :: Int) . prettyFlatList :: [Doc ann] -> Doc ann prettyFlatList xs = "[" <+> commaSep xs <+> "]" +prettyNonEmptyList :: NonEmpty (Doc ann) -> Doc ann +prettyNonEmptyList xs = case NonEmpty.init xs of + [] -> NonEmpty.last xs + ys -> commaSep ys <+> "and" <+> NonEmpty.last xs + -------------------------------------------------------------------------------- -- Useful utility functions diff --git a/vehicle/src/Vehicle/Prelude/Supply.hs b/vehicle/src/Vehicle/Prelude/Supply.hs index 9c66b0d5d..f64388249 100644 --- a/vehicle/src/Vehicle/Prelude/Supply.hs +++ b/vehicle/src/Vehicle/Prelude/Supply.hs @@ -4,17 +4,20 @@ module Vehicle.Prelude.Supply ( MonadSupply (..), SupplyT, runSupplyT, + mapSupplyT, Supply, runSupply, ) where import Control.Monad.Except (ExceptT, MonadError (..)) +import Control.Monad.IO.Class import Control.Monad.Identity (Identity, runIdentity) import Control.Monad.Reader (MonadReader (..), ReaderT) -import Control.Monad.State (MonadState (..), StateT, evalStateT) +import Control.Monad.State (MonadState (..), StateT, evalStateT, mapStateT) import Control.Monad.Trans (MonadTrans (..)) import Control.Monad.Writer (WriterT) +import Vehicle.Prelude.IO class (Monad m) => MonadSupply s m where demand :: m s @@ -27,6 +30,12 @@ newtype SupplyT s m a = SupplyT runSupplyT :: (Monad m) => SupplyT s m a -> [s] -> m a runSupplyT (SupplyT m) = evalStateT m +mapSupplyT :: + (m (a, [s]) -> n (b, [s])) -> + SupplyT s m a -> + SupplyT s n b +mapSupplyT f m = SupplyT (mapStateT f (unsupplyT m)) + type Supply s a = SupplyT s Identity a runSupply :: Supply s a -> [s] -> a @@ -62,3 +71,10 @@ instance (MonadReader e m) => MonadReader e (SupplyT s m) where instance (MonadState e m) => MonadState e (SupplyT s m) where get = lift get put = lift . put + +instance (MonadIO m) => MonadIO (SupplyT e m) where + liftIO = lift . liftIO + +instance (MonadStdIO m) => MonadStdIO (SupplyT e m) where + writeStdout = lift . writeStdout + writeStderr = lift . writeStderr diff --git a/vehicle/src/Vehicle/Prelude/Warning.hs b/vehicle/src/Vehicle/Prelude/Warning.hs index d3d0ce03f..f928a3bf0 100644 --- a/vehicle/src/Vehicle/Prelude/Warning.hs +++ b/vehicle/src/Vehicle/Prelude/Warning.hs @@ -1,33 +1,135 @@ -module Vehicle.Prelude.Warning where +module Vehicle.Prelude.Warning + ( CompileWarning (..), + SummarisedCompileWarning (..), + groupWarnings, + ) +where -import Data.Hashable (Hashable (..)) +import Data.List (sortBy) +import Data.List.NonEmpty (NonEmpty, sort) +import Data.Map (Map) +import Data.Map qualified as Map (insertWith, singleton, toList, unionWith) import Data.Set (Set) +import Data.Set qualified as Set (singleton) import Vehicle.Backend.Prelude (Target) -import Vehicle.Backend.Queries.Variable import Vehicle.Resource (ExternalResource) import Vehicle.Syntax.AST import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat.Core +import Vehicle.Verify.Variable + +-------------------------------------------------------------------------------- +-- Non-unique compile warnings --- | Exhaustive list of warnings thrown by the Vehicle compiler. data CompileWarning - = UnusedResource ExternalResource (Set Name) - | ResourcesUnnecessariyProvidedForBackend Target [(ExternalResource, Name)] - | ResortingtoFMElimination Name (Set MixedVariable) + = UnusedResources ExternalResource (Set Name) + | UnnecessaryResourcesProvided Target [(ExternalResource, Name)] | TrivialProperty PropertyAddress Bool - | UnsoundStrictOrderConversion Name QueryFormatID - | AllConstantInputsMarabouBug Name - | UnderSpecifiedNetworkInputs Name QueryFormatID [(NetworkVariable, UnderConstrainedVariableStatus)] - --- | Used to prevent duplicate warnings being thrown. Return `Nothing` if duplicates are fine, --- otherwise return the hash of the relevant parts of the warning for which different values --- should return multiple warnings. -warningDuplicateDetectionHash :: CompileWarning -> Maybe Int -warningDuplicateDetectionHash w = case w of - UnusedResource {} -> Nothing - ResourcesUnnecessariyProvidedForBackend {} -> Nothing - TrivialProperty {} -> Nothing - ResortingtoFMElimination name _vars -> Just $ hash (1 :: Int, name) - UnsoundStrictOrderConversion name _format -> Just $ hash (2 :: Int, name) - AllConstantInputsMarabouBug name -> Just $ hash (3 :: Int, name) - UnderSpecifiedNetworkInputs name _format _vars -> Just $ hash (4 :: Int, name) + | UnderSpecifiedProblemSpaceVar PropertyAddress UserRationalVariable + | UnsoundStrictOrderConversion QueryFormatID QueryAddress + | AllConstantNetworkInputVars QueryFormatID QueryAddress + | UnboundedNetworkInputVariables QueryFormatID QueryAddress MetaNetwork [(NetworkRationalVariable, UnderConstrainedVariableStatus)] + +data SummarisedCompileWarning + = UnusedResourcesSummary ExternalResource (Set Name) + | UnnecessaryResourcesProvidedSummary Target [(ExternalResource, Name)] + | TrivialPropertySummary PropertyAddress Bool + | UnderSpecifiedProblemSpaceVariablesSummary PropertyAddress (Set UserRationalVariable) + | UnsoundStrictOrderConversionsSummary QueryFormatID PropertyAddress Int + | AllConstantNetworkInputVariablesSummary QueryFormatID PropertyAddress (NonEmpty QueryID) + | UnboundedNetworkInputVariablesSummary QueryFormatID PropertyAddress [(NonEmpty QueryID, [(NetworkRationalVariable, UnderConstrainedVariableStatus)])] + +-------------------------------------------------------------------------------- +-- Combinable compile warnings + +type UnderConstrainedSignature = (MetaNetwork, [(NetworkRationalVariable, UnderConstrainedVariableStatus)]) + +data CombiningState = CombiningState + { uniqueWarnings :: [SummarisedCompileWarning], + underSpecifiedProblemSpaceVars :: Map PropertyAddress (Set UserRationalVariable), + unsoundStrictnessConversions :: Map (QueryFormatID, PropertyAddress) Int, + allConstantNetworkInputVars :: Map (QueryFormatID, PropertyAddress) (NonEmpty QueryID), + unboundedNetworkInputs :: Map (QueryFormatID, PropertyAddress) (Map UnderConstrainedSignature (NonEmpty QueryID)) + } + +emptyState :: CombiningState +emptyState = CombiningState mempty mempty mempty mempty mempty + +addWarningToState :: CombiningState -> CompileWarning -> CombiningState +addWarningToState CombiningState {..} = \case + UnusedResources r names -> + CombiningState + { uniqueWarnings = UnusedResourcesSummary r names : uniqueWarnings, + .. + } + UnnecessaryResourcesProvided r names -> + CombiningState + { uniqueWarnings = UnnecessaryResourcesProvidedSummary r names : uniqueWarnings, + .. + } + TrivialProperty r names -> + CombiningState + { uniqueWarnings = TrivialPropertySummary r names : uniqueWarnings, + .. + } + UnderSpecifiedProblemSpaceVar property var -> + CombiningState + { underSpecifiedProblemSpaceVars = Map.insertWith (<>) property (Set.singleton var) underSpecifiedProblemSpaceVars, + .. + } + UnsoundStrictOrderConversion queryFormat (propertyAddress, _queryID) -> + CombiningState + { unsoundStrictnessConversions = Map.insertWith (+) (queryFormat, propertyAddress) 1 unsoundStrictnessConversions, + .. + } + AllConstantNetworkInputVars queryFormat (propertyAddress, queryID) -> + CombiningState + { allConstantNetworkInputVars = Map.insertWith (<>) (queryFormat, propertyAddress) [queryID] allConstantNetworkInputVars, + .. + } + UnboundedNetworkInputVariables queryFormat (propertyAddress, queryID) metaNetwork vars -> + CombiningState + { unboundedNetworkInputs = Map.insertWith (Map.unionWith (<>)) (queryFormat, propertyAddress) (Map.singleton (metaNetwork, vars) [queryID]) unboundedNetworkInputs, + .. + } + +groupWarnings :: [CompileWarning] -> [SummarisedCompileWarning] +groupWarnings warnings = stateToWarnings $ foldl addWarningToState emptyState warnings + +stateToWarnings :: CombiningState -> [SummarisedCompileWarning] +stateToWarnings CombiningState {..} = + sortBy compareWarning $ + do + uniqueWarnings + <> fmap combineUnderSpecifiedProblemSpaceVars (Map.toList underSpecifiedProblemSpaceVars) + <> fmap combineUnsoundStrictnessConversions (Map.toList unsoundStrictnessConversions) + <> fmap combineAllConstantNetworkInputVars (Map.toList allConstantNetworkInputVars) + <> fmap combineUnboundedNetworkInputVars (Map.toList unboundedNetworkInputs) + +combineUnderSpecifiedProblemSpaceVars :: (PropertyAddress, Set UserRationalVariable) -> SummarisedCompileWarning +combineUnderSpecifiedProblemSpaceVars (property, vars) = UnderSpecifiedProblemSpaceVariablesSummary property vars + +combineUnsoundStrictnessConversions :: ((QueryFormatID, PropertyAddress), Int) -> SummarisedCompileWarning +combineUnsoundStrictnessConversions ((queryFormatID, property), number) = UnsoundStrictOrderConversionsSummary queryFormatID property number + +combineAllConstantNetworkInputVars :: ((QueryFormatID, PropertyAddress), NonEmpty QueryID) -> SummarisedCompileWarning +combineAllConstantNetworkInputVars ((queryFormatID, property), queries) = AllConstantNetworkInputVariablesSummary queryFormatID property (sort queries) + +combineUnboundedNetworkInputVars :: ((QueryFormatID, PropertyAddress), Map UnderConstrainedSignature (NonEmpty QueryID)) -> SummarisedCompileWarning +combineUnboundedNetworkInputVars ((queryFormatID, property), constraintsBySignature) = do + let result = (\((_metaNetwork, constraints), queries) -> (queries, constraints)) <$> Map.toList constraintsBySignature + UnboundedNetworkInputVariablesSummary queryFormatID property result + +compareWarning :: SummarisedCompileWarning -> SummarisedCompileWarning -> Ordering +compareWarning w1 w2 = compare (warningPropertyId w1) (warningPropertyId w2) + where + warningPropertyId :: SummarisedCompileWarning -> Maybe PropertyID + warningPropertyId w = + propertyID <$> case w of + UnusedResourcesSummary {} -> Nothing + UnnecessaryResourcesProvidedSummary {} -> Nothing + TrivialPropertySummary address _ -> Just address + UnderSpecifiedProblemSpaceVariablesSummary address _ -> Just address + UnsoundStrictOrderConversionsSummary _ address _ -> Just address + AllConstantNetworkInputVariablesSummary _ address _ -> Just address + UnboundedNetworkInputVariablesSummary _ address _ -> Just address diff --git a/vehicle/src/Vehicle/TypeCheck.hs b/vehicle/src/Vehicle/TypeCheck.hs index d22fefb54..583886144 100644 --- a/vehicle/src/Vehicle/TypeCheck.hs +++ b/vehicle/src/Vehicle/TypeCheck.hs @@ -62,7 +62,7 @@ parseAndTypeCheckExpr expr = do parseExprText :: (MonadCompile m) => Text -> m (Expr Name Builtin) parseExprText txt = case runExcept (parseExpr User =<< readExpr txt) of - Left err -> throwError $ ParseError err + Left err -> throwError $ ParseError User err Right expr -> return expr typeCheckUserProg :: @@ -110,9 +110,9 @@ typeCheckOrLoadProg modul imports specificationFile = do parseProgText :: (MonadCompile m) => Module -> Text -> m (Prog Name Builtin) parseProgText modul txt = do case runExcept (readAndParseProg modul txt) of - Left err -> throwError $ ParseError err + Left err -> throwError $ ParseError modul err Right prog -> case traverseDecls (parseDecl modul) prog of - Left err -> throwError $ ParseError err + Left err -> throwError $ ParseError modul err Right prog' -> return prog' loadLibrary :: (MonadIO m, MonadCompile m) => Library -> m (Prog Ix Builtin) @@ -141,7 +141,8 @@ runCompileMonad :: ExceptT CompileError (ImmediateLoggerT m) a -> m a runCompileMonad loggingSettings x = do - errorOrResult <- runImmediateLogger loggingSettings (logCompileError x) + errorOrResult <- runImmediateLoggerT loggingSettings (logCompileError x) + -- errorOrResult <- runSilentLoggerT (logCompileError x) case errorOrResult of Left err -> fatalError $ pretty $ details err Right val -> return val diff --git a/vehicle/src/Vehicle/Validate.hs b/vehicle/src/Vehicle/Validate.hs index 470dc238c..915840df2 100644 --- a/vehicle/src/Vehicle/Validate.hs +++ b/vehicle/src/Vehicle/Validate.hs @@ -21,7 +21,7 @@ newtype ValidateOptions = ValidateOptions deriving (Eq, Show) validate :: LoggingSettings -> ValidateOptions -> IO () -validate loggingSettings checkOptions = runImmediateLogger loggingSettings $ do +validate loggingSettings checkOptions = runImmediateLoggerT loggingSettings $ do -- If the user has specified no logging target for check mode then -- default to command-line. status <- checkSpecificationStatus checkOptions diff --git a/vehicle/src/Vehicle/Verify.hs b/vehicle/src/Vehicle/Verify.hs index 0b443a710..b6b64829d 100644 --- a/vehicle/src/Vehicle/Verify.hs +++ b/vehicle/src/Vehicle/Verify.hs @@ -14,6 +14,7 @@ import Vehicle.Compile (CompileOptions (..), compile) import Vehicle.Compile.Prelude (DatasetLocations, NetworkLocations, ParameterValues) import Vehicle.Prelude import Vehicle.Prelude.Logging +import Vehicle.Verify.Core import Vehicle.Verify.Specification.IO import Vehicle.Verify.Verifier @@ -31,7 +32,7 @@ data VerifyOptions = VerifyOptions } deriving (Eq, Show) -verify :: LoggingSettings -> VerifyOptions -> IO () +verify :: (MonadStdIO IO) => LoggingSettings -> VerifyOptions -> IO () verify loggingSettings options@VerifyOptions {..} = do validQueryFolder <- isValidQueryFolder specification let verifier = verifiers verifierID @@ -45,7 +46,7 @@ verify loggingSettings options@VerifyOptions {..} = do verifyQueries loggingSettings folder verifier verifierExecutable -- | Compiles the specification to a temporary directory and then tries to verify it. -compileAndVerifyQueries :: LoggingSettings -> VerifyOptions -> (FilePath -> IO ()) -> IO () +compileAndVerifyQueries :: (MonadStdIO IO) => LoggingSettings -> VerifyOptions -> (FilePath -> IO ()) -> IO () compileAndVerifyQueries loggingSettings VerifyOptions {..} verifyCommand = do let queryFormat = VerifierQueries $ verifierQueryFormat $ verifiers verifierID @@ -68,9 +69,9 @@ compileAndVerifyQueries loggingSettings VerifyOptions {..} verifyCommand = do verifyCommand tempDir -verifyQueries :: LoggingSettings -> FilePath -> Verifier -> VerifierExecutable -> IO () +verifyQueries :: (MonadStdIO IO) => LoggingSettings -> FilePath -> Verifier -> VerifierExecutable -> IO () verifyQueries loggingSettings queryFolder verifier verifierExecutable = do - runImmediateLogger loggingSettings $ do + runImmediateLoggerT loggingSettings $ do verifySpecification queryFolder verifier verifierExecutable -- | Tries to locate the executable for the verifier at the provided @@ -119,7 +120,8 @@ invalidTargetError target = <> line <> indent 2 - ( "i) a" <+> pretty specificationFileExtension + ( "i) a" + <+> pretty specificationFileExtension <> line <> "ii) a folder containing a" <+> pretty specificationCacheIndexFileExtension diff --git a/vehicle/src/Vehicle/Verify/Core.hs b/vehicle/src/Vehicle/Verify/Core.hs index 80cb48ab4..af03b8432 100644 --- a/vehicle/src/Vehicle/Verify/Core.hs +++ b/vehicle/src/Vehicle/Verify/Core.hs @@ -1,100 +1,40 @@ module Vehicle.Verify.Core where import Data.Aeson (FromJSON, ToJSON) -import Data.Map (Map) -import Data.Map qualified as Map +import Data.List.NonEmpty (NonEmpty) +import Data.List.NonEmpty qualified as NonEmpty +import Data.Set (Set) +import Data.Set qualified as Set import Data.Text (Text, unpack) -import Data.Vector (Vector) -import Data.Vector qualified as Vector (toList) import GHC.Generics (Generic) import System.FilePath ((<.>)) -import Vehicle.Backend.Queries.LinearExpr (Assertion, SparseLinearExpr) -import Vehicle.Backend.Queries.Variable +import Vehicle.Compile.Context.Bound.Core (GenericBoundCtx) import Vehicle.Compile.Resource +import Vehicle.Data.BooleanExpr +import Vehicle.Data.LinearExpr import Vehicle.Prelude import Vehicle.Syntax.AST +import Vehicle.Syntax.Builtin.BasicOperations +import Vehicle.Verify.Variable -------------------------------------------------------------------------------- --- Assignments to variables - --- | A (satisfying) assignment to a set of reduced network-level variables. -newtype NetworkVariableAssignment - = NetworkVariableAssignment (Vector Rational) - -instance Pretty NetworkVariableAssignment where - pretty :: NetworkVariableAssignment -> Doc a - pretty (NetworkVariableAssignment assignment) = do - vsep (prettyVariable <$> zip [0 ..] (Vector.toList assignment)) - where - prettyVariable :: (Int, Rational) -> Doc a - prettyVariable (var, value) = "x" <> pretty var <> ":" <+> pretty value - --- | A (satisfying) assignment to a set of user-level variables. -newtype UserVariableAssignment - = UserVariableAssignment [(UserVariable, VariableValue)] - deriving (Generic) - -instance ToJSON UserVariableAssignment - -instance FromJSON UserVariableAssignment - -instance Pretty UserVariableAssignment where - pretty :: UserVariableAssignment -> Doc a - pretty (UserVariableAssignment assignment) = do - vsep (fmap prettyVariable assignment) - where - prettyVariable :: (UserVariable, VariableValue) -> Doc a - prettyVariable (var, value) = do - let name = pretty $ userVarName var - let valueDoc = prettyConstant True (userVarDimensions var) value - name <> ":" <+> valueDoc - --------------------------------------------------------------------------------- --- Addresses - --- | The number of an individual query within a `Property` when traversed --- depth-first. -type QueryID = Int - -type QueryAddress = (PropertyAddress, QueryID) - -calculateQueryFileName :: QueryAddress -> FilePath -calculateQueryFileName (PropertyAddress propertyName propertyIndices, queryID) = do - let propertyStr - | null propertyIndices = "" - | otherwise = showTensorIndices propertyIndices - - unpack propertyName - <> propertyStr - <> "-query" - <> show queryID <.> "txt" +-- Meta-network --- | A unique identifier for every individual property that needs to be verified. --- Not simply an identifier, as we need to identifier sub-properties in tensors of --- properties. -data PropertyAddress = PropertyAddress - { propertyName :: Name, - propertyIndices :: TensorIndices +data NetworkContextInfo = NetworkContextInfo + { networkFilepath :: FilePath, + networkType :: NetworkType } - deriving (Show, Generic) + deriving (Eq, Ord, Show, Generic) -instance ToJSON PropertyAddress +instance ToJSON NetworkContextInfo -instance FromJSON PropertyAddress - -instance Pretty PropertyAddress where - pretty (PropertyAddress name indices) = - concatWith (\a b -> a <> "!" <> b) (pretty name : fmap pretty indices) - --------------------------------------------------------------------------------- --- Meta-network +instance FromJSON NetworkContextInfo data MetaNetworkEntry = MetaNetworkEntry { metaNetworkEntryName :: Name, - metaNetworkEntryType :: NetworkType, - metaNetworkEntryFilePath :: FilePath + metaNetworkEntryInfo :: NetworkContextInfo } - deriving (Show, Generic) + deriving (Eq, Ord, Show, Generic) instance ToJSON MetaNetworkEntry @@ -105,12 +45,20 @@ instance Pretty MetaNetworkEntry where pretty metaNetworkEntryName <> ":" <> softline - <> pretty metaNetworkEntryType + <> pretty (networkType metaNetworkEntryInfo) -- <> softline <> parens (pretty metaNetworkEntryFilePath) -- | A list of neural networks used in a given query. -type MetaNetwork = [MetaNetworkEntry] +data MetaNetwork = MetaNetwork + { networkEntries :: [MetaNetworkEntry], + variables :: [NetworkRationalVariable] + } + deriving (Eq, Ord, Show, Generic) + +instance ToJSON MetaNetwork + +instance FromJSON MetaNetwork -------------------------------------------------------------------------------- -- Queries misc @@ -126,37 +74,6 @@ type QueryText = Text -- query sets. e.g. prop = (forall x . P x) and (exists x . Q y). type QuerySetNegationStatus = Bool -metaNetworkEntryVariables :: - Bool -> - MetaNetworkEntry -> - (Map Name Int, [[NetworkVariable]]) -> - (Map Name Int, [[NetworkVariable]]) -metaNetworkEntryVariables reduced MetaNetworkEntry {..} (applications, vars) = do - let applicationNumber = Map.findWithDefault 0 metaNetworkEntryName applications - let newApplications = Map.insert metaNetworkEntryName (applicationNumber + 1) applications - - let (inputIndices, outputIndices, inputDimensions, outputDimensions) - | not reduced = do - let inputDims = dimensions $ inputTensor metaNetworkEntryType - let outputDims = dimensions $ outputTensor metaNetworkEntryType - ([Nothing], [Nothing], inputDims, outputDims) - | otherwise = do - let inputs = Just <$> [0 .. tensorSize (inputTensor metaNetworkEntryType) - 1] - let outputs = Just <$> [0 .. tensorSize (outputTensor metaNetworkEntryType) - 1] - (inputs, outputs, [], []) - let mkVariable = NetworkVariable metaNetworkEntryName applicationNumber - let mkInputVariable = mkVariable inputDimensions Input - let mkOutputVariable = mkVariable outputDimensions Output - let inputVariables = [mkInputVariable i | i <- inputIndices] - let outputVariables = [mkOutputVariable i | i <- outputIndices] - - (newApplications, (inputVariables <> outputVariables) : vars) - -metaNetworkVariables :: Bool -> MetaNetwork -> [NetworkVariable] -metaNetworkVariables reduced metaNetwork = do - let (_, result) = foldr (metaNetworkEntryVariables reduced) (mempty, mempty) metaNetwork - concat (reverse result) - -------------------------------------------------------------------------------- -- Query results @@ -175,63 +92,54 @@ instance (Pretty witness) => Pretty (QueryResult witness) where UnSAT -> "UNSAT" -------------------------------------------------------------------------------- --- Variable reconstruction - --- | A solution for a normalised user variable that is an equation --- where the coefficient for that variable is 1. -newtype GaussianVariableSolution = GaussianVariableSolution - { solutionEquality :: SparseLinearExpr MixedVariable - } - deriving (Show, Generic) +-- Property addresses -instance ToJSON GaussianVariableSolution +-- | The number of an individual property within a specification. +type PropertyID = Int -instance FromJSON GaussianVariableSolution +-- | A name of a property in the specification. +type PropertyName = Name -instance Pretty GaussianVariableSolution where - pretty = pretty . solutionEquality +-- | A set of properties in the specification. +type PropertyNames = [PropertyName] --- | A FM solution for an normalised user variable is two lists of constraints. --- The variable value must be greater than the first set of assertions, and less than --- the second set of assertions. -data FourierMotzkinVariableSolution = FMSolution - { lowerBounds :: [Assertion MixedVariable], - upperBounds :: [Assertion MixedVariable] +-- | A unique identifier for every individual property that needs to be verified. +-- Not simply an identifier, as we need to identifier sub-properties in tensors of +-- properties. +data PropertyAddress = PropertyAddress + { propertyID :: PropertyID, + propertyName :: PropertyName, + propertyIndices :: TensorIndices } - deriving (Show, Generic) + deriving (Eq, Ord, Show, Generic) -instance ToJSON FourierMotzkinVariableSolution +instance ToJSON PropertyAddress -instance FromJSON FourierMotzkinVariableSolution +instance FromJSON PropertyAddress --- | One step in the process for transforming unreduced user variables into --- reduced network input and output variables. -data VariableNormalisationStep - = EliminateViaGaussian MixedVariable GaussianVariableSolution - | EliminateViaFourierMotzkin MixedVariable FourierMotzkinVariableSolution - | Reduce MixedVariable - | Introduce MixedVariable - deriving (Show, Generic) +instance Pretty PropertyAddress where + pretty (PropertyAddress _ name indices) = + concatWith (\a b -> a <> "!" <> b) (pretty name : fmap pretty indices) -instance ToJSON VariableNormalisationStep +calculatePropertyFilePrefix :: PropertyAddress -> FilePath +calculatePropertyFilePrefix (PropertyAddress _ propertyName propertyIndices) = do + let indexStr + | null propertyIndices = "" + | otherwise = showTensorIndices propertyIndices + unpack propertyName <> indexStr -instance FromJSON VariableNormalisationStep +-------------------------------------------------------------------------------- +-- Addresses -instance Pretty VariableNormalisationStep where - pretty = \case - EliminateViaGaussian v s -> "EliminateGaussian[" <+> pretty v <+> "=" <+> pretty s <+> "]" - EliminateViaFourierMotzkin v _ -> "EliminateFourierMotzkin[" <+> pretty v <+> "]" - Reduce v -> "Reduce[" <+> pretty v <+> "]" - Introduce v -> "Introduce[" <+> pretty v <+> "]" - --- | The steps for transforming unreduced user variables into reduced network --- input and output varibles. --- These are used to recreate a satisfying assignment for the user variables --- from the satisfying assignment for the network variables spat out by the --- verifier. --- --- The steps are stored in the same order they occured during compilation. -type VariableNormalisationSteps = [VariableNormalisationStep] +-- | The number of an individual query within a `Property` when traversed +-- depth-first. +type QueryID = Int + +type QueryAddress = (PropertyAddress, QueryID) + +calculateQueryFileName :: QueryAddress -> FilePath +calculateQueryFileName (propertyAddress, queryID) = do + calculatePropertyFilePrefix propertyAddress <> "-query" <> show queryID <.> "txt" -------------------------------------------------------------------------------- -- Variable status @@ -240,7 +148,13 @@ data UnderConstrainedVariableStatus = Unconstrained | BoundedAbove | BoundedBelow - deriving (Show, Eq) + deriving (Show, Eq, Ord) + +instance Pretty UnderConstrainedVariableStatus where + pretty = \case + Unconstrained -> "Unconstrained" + BoundedAbove -> "BoundedAbove" + BoundedBelow -> "BoundedBelow" instance Semigroup UnderConstrainedVariableStatus where Unconstrained <> r = r @@ -249,25 +163,44 @@ instance Semigroup UnderConstrainedVariableStatus where r <> BoundedAbove = r BoundedBelow <> BoundedBelow = BoundedBelow --- | How the value of a particular value of a variable is constrained. -data VariableConstraintStatus - = UnderConstrained UnderConstrainedVariableStatus - | Bounded - | Constant - deriving (Show, Eq) - -instance Semigroup VariableConstraintStatus where - UnderConstrained r <> UnderConstrained s = case (r, s) of - (BoundedBelow, BoundedAbove) -> Bounded - (BoundedAbove, BoundedBelow) -> Bounded - _ -> UnderConstrained (r <> s) - UnderConstrained {} <> r = r - r <> UnderConstrained {} = r - Bounded <> r = r - r <> Bounded = r - Constant <> Constant = Constant - -toUnderConstrainedStatus :: VariableConstraintStatus -> Maybe UnderConstrainedVariableStatus -toUnderConstrainedStatus = \case - UnderConstrained s -> Just s - _ -> Nothing +-------------------------------------------------------------------------------- +-- Queries + +data QueryRelation + = EqualRel + | OrderRel OrderOp + deriving (Show, Eq, Ord) + +instance Pretty QueryRelation where + pretty = \case + EqualRel -> "=" + OrderRel op -> pretty op + +flipQueryRel :: QueryRelation -> QueryRelation +flipQueryRel = \case + EqualRel -> EqualRel + OrderRel op -> OrderRel (flipOrder op) + +-- A single assertion for a query. +data QueryAssertion = QueryAssertion + { lhs :: NonEmpty (Coefficient, NetworkRationalVariable), + rel :: QueryRelation, + rhs :: Rational + } + +instance Pretty QueryAssertion where + pretty (QueryAssertion lhs rel rhs) = pretty lhs <> pretty rel <> pretty rhs + +queryAssertionVariables :: QueryAssertion -> Set NetworkRationalVariable +queryAssertionVariables = Set.fromList . fmap snd . NonEmpty.toList . lhs + +-- | The contents of a single query for a verifier. +data QueryContents = QueryContents + { queryVariables :: GenericBoundCtx NetworkRationalVariable, + queryAssertions :: ConjunctAll QueryAssertion + } + +{- +instance Pretty QueryContents where + pretty (QueryContents _varNames assertions) = pretty assertions +-} diff --git a/vehicle/src/Vehicle/Verify/QueryFormat/Core.hs b/vehicle/src/Vehicle/Verify/QueryFormat/Core.hs index 31561e06c..4523993ed 100644 --- a/vehicle/src/Vehicle/Verify/QueryFormat/Core.hs +++ b/vehicle/src/Vehicle/Verify/QueryFormat/Core.hs @@ -8,7 +8,7 @@ import Vehicle.Prelude data QueryFormatID = MarabouQueries | VNNLibQueries - deriving (Show, Eq, Bounded, Enum) + deriving (Show, Eq, Ord, Bounded, Enum) instance Pretty QueryFormatID where pretty = \case diff --git a/vehicle/src/Vehicle/Verify/QueryFormat/Interface.hs b/vehicle/src/Vehicle/Verify/QueryFormat/Interface.hs index 8d8a0db2d..d8637a890 100644 --- a/vehicle/src/Vehicle/Verify/QueryFormat/Interface.hs +++ b/vehicle/src/Vehicle/Verify/QueryFormat/Interface.hs @@ -2,20 +2,21 @@ module Vehicle.Verify.QueryFormat.Interface where import Control.Monad.Except (MonadError) import Data.Text (Text) -import Vehicle.Backend.Queries.LinearExpr import Vehicle.Compile.Error (CompileError) -import Vehicle.Compile.Prelude (DeclProvenance, ExternalOutputFormat, MonadLogger) +import Vehicle.Compile.Prelude (ExternalOutputFormat, MonadLogger) +import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat.Core -- | A format for an output query that verifiers can parse. data QueryFormat = QueryFormat { queryFormatID :: QueryFormatID, queryOutputFormat :: ExternalOutputFormat, - -- | The command to compile an individual query - compileQuery :: + supportsStrictInequalities :: Bool, + -- | The command to format an individual query + formatQuery :: forall m. (MonadLogger m, MonadError CompileError m) => - DeclProvenance -> - CLSTProblem -> + QueryAddress -> + QueryContents -> m Text } diff --git a/vehicle/src/Vehicle/Verify/QueryFormat/Marabou.hs b/vehicle/src/Vehicle/Verify/QueryFormat/Marabou.hs index e57a84654..becc7f7f9 100644 --- a/vehicle/src/Vehicle/Verify/QueryFormat/Marabou.hs +++ b/vehicle/src/Vehicle/Verify/QueryFormat/Marabou.hs @@ -1,23 +1,21 @@ module Vehicle.Verify.QueryFormat.Marabou ( marabouQueryFormat, + compileVar, ) where import Control.Monad (forM) import Control.Monad.Except (MonadError (..)) -import Data.Bifunctor (Bifunctor (..)) import Data.List.NonEmpty (NonEmpty (..)) -import Data.Map (Map) -import Data.Map qualified as Map -import Vehicle.Backend.Queries.LinearExpr -import Vehicle.Backend.Queries.Variable -import Vehicle.Compile.Error (CompileError (UnsupportedInequality)) +import Vehicle.Compile.Error (CompileError (..)) import Vehicle.Compile.Prelude +import Vehicle.Data.LinearExpr import Vehicle.Prelude.Warning import Vehicle.Syntax.Builtin import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat.Core import Vehicle.Verify.QueryFormat.Interface +import Vehicle.Verify.Variable -------------------------------------------------------------------------------- -- Marabou query format @@ -27,7 +25,8 @@ marabouQueryFormat :: QueryFormat marabouQueryFormat = QueryFormat { queryFormatID = MarabouQueries, - compileQuery = compileMarabouQuery, + formatQuery = compileMarabouQuery, + supportsStrictInequalities = False, queryOutputFormat = ExternalOutputFormat { formatName = pretty MarabouQueries, @@ -42,57 +41,56 @@ marabouQueryFormat = -- level. compileMarabouQuery :: (MonadLogger m, MonadError CompileError m) => - DeclProvenance -> - CLSTProblem -> + QueryAddress -> + QueryContents -> m QueryText -compileMarabouQuery propertyName (CLSTProblem variables assertions) = do - let variableNames = sequentialNetworkVariableNaming "x" "y" variables - let variableNamesMap = Map.fromList (zip variables variableNames) - assertionDocs <- forM assertions (compileAssertion propertyName variableNamesMap) +compileMarabouQuery address (QueryContents _variables assertions) = do + assertionDocs <- forM assertions (compileAssertion address) let assertionsDoc = vsep assertionDocs return $ layoutAsText assertionsDoc compileAssertion :: (MonadLogger m, MonadError CompileError m) => - DeclProvenance -> - Map NetworkVariable Name -> - Assertion NetworkVariable -> + QueryAddress -> + QueryAssertion -> m (Doc a) -compileAssertion propertyName varNames assertion = do - let (coeffVars, rel, constant) = convertToSparseFormat varNames assertion - let (coeffVars', rel', constant', multipleVariables) = - case coeffVars of - (coeff, var) :| [] -> do - -- Workaround for bug - -- https://github.com/NeuralNetworkVerification/Marabou/issues/625 - let newCoeffVars = (1, var) :| [] - let newRel = if coeff < 0 then second flipOrder rel else rel - let newConstant = constant / coeff - (newCoeffVars, newRel, newConstant, False) - _ -> (coeffVars, rel, constant, True) +compileAssertion address QueryAssertion {..} = do + let (coeffVars', rel', constant', multipleVariables) = case lhs of + (coeff, var) :| [] -> do + -- Workaround for bug https://github.com/NeuralNetworkVerification/Marabou/issues/625 + let newCoeffVars = (1, var) :| [] + let newRel = if coeff < 0 then flipQueryRel rel else rel + let newConstant = rhs / coeff + (newCoeffVars, newRel, newConstant, False) + _ -> (lhs, rel, rhs, True) - let compiledLHS = hsep (fmap (compileVar multipleVariables) coeffVars') - compiledRel <- compileRel propertyName rel' + compiledRel <- compileRel address rel' + let compiledLHS = hsep (fmap (compileCoefVar multipleVariables) coeffVars') let compiledRHS = prettyRationalAsFloat constant' return $ compiledLHS <+> compiledRel <+> compiledRHS -compileRel :: (MonadLogger m, MonadError CompileError m) => DeclProvenance -> Either EqualityOp OrderOp -> m (Doc a) -compileRel declProv@(ident, _) = \case - Left Eq -> return "=" - Left Neq -> throwError $ UnsupportedInequality MarabouQueries declProv - Right Le -> return "<=" - Right Ge -> return ">=" +compileRel :: (MonadLogger m, MonadError CompileError m) => QueryAddress -> QueryRelation -> m (Doc a) +compileRel address = \case + EqualRel -> return "=" + OrderRel Le -> return "<=" + OrderRel Ge -> return ">=" -- Suboptimal. Marabou doesn't currently support strict inequalities. -- See https://github.com/vehicle-lang/vehicle/issues/74 for details. - Right Lt -> do - logWarning (UnsoundStrictOrderConversion (nameOf ident) MarabouQueries) + OrderRel Lt -> do + logWarning (UnsoundStrictOrderConversion MarabouQueries address) return "<=" - Right Gt -> do - logWarning (UnsoundStrictOrderConversion (nameOf ident) MarabouQueries) + OrderRel Gt -> do + logWarning (UnsoundStrictOrderConversion MarabouQueries address) return ">=" -compileVar :: Bool -> (Rational, Name) -> Doc a -compileVar False (1, var) = pretty var -compileVar True (1, var) = "+" <> pretty var -compileVar _ (-1, var) = "-" <> pretty var -compileVar _ (coefficient, var) = prettyRationalAsFloat coefficient <> pretty var +compileCoefVar :: Bool -> (Coefficient, NetworkRationalVariable) -> Doc a +compileCoefVar False (1, var) = compileVar var +compileCoefVar True (1, var) = "+" <> compileVar var +compileCoefVar _ (-1, var) = "-" <> compileVar var +compileCoefVar _ (coefficient, var) = prettyRationalAsFloat coefficient <> compileVar var + +compileVar :: NetworkRationalVariable -> Doc a +compileVar var = do + let name = if inputOrOutput (originalVar var) == Input then "x" else "y" + let index = computeAbsoluteIndex var + name <> pretty index diff --git a/vehicle/src/Vehicle/Verify/QueryFormat/VNNLib.hs b/vehicle/src/Vehicle/Verify/QueryFormat/VNNLib.hs index 202f3f1eb..14ba6e3f0 100644 --- a/vehicle/src/Vehicle/Verify/QueryFormat/VNNLib.hs +++ b/vehicle/src/Vehicle/Verify/QueryFormat/VNNLib.hs @@ -2,15 +2,13 @@ module Vehicle.Verify.QueryFormat.VNNLib where import Control.Monad (forM) import Data.List.NonEmpty qualified as NonEmpty -import Data.Map (Map) -import Data.Map qualified as Map -import Vehicle.Backend.Queries.LinearExpr -import Vehicle.Backend.Queries.Variable import Vehicle.Compile.Prelude +import Vehicle.Data.LinearExpr import Vehicle.Syntax.Builtin import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat.Core import Vehicle.Verify.QueryFormat.Interface +import Vehicle.Verify.Variable -------------------------------------------------------------------------------- -- Marabou query format @@ -20,7 +18,8 @@ vnnlibQueryFormat :: QueryFormat vnnlibQueryFormat = QueryFormat { queryFormatID = VNNLibQueries, - compileQuery = compileVNNLibQuery, + formatQuery = compileVNNLibQuery, + supportsStrictInequalities = True, queryOutputFormat = ExternalOutputFormat { formatName = pretty VNNLibQueries, @@ -33,43 +32,40 @@ vnnlibQueryFormat = -- | Compiles an expression representing a single Marabou query. The expression -- passed should only have conjunctions and existential quantifiers at the boolean -- level. -compileVNNLibQuery :: (MonadLogger m) => DeclProvenance -> CLSTProblem -> m QueryText -compileVNNLibQuery _propertyName (CLSTProblem variables assertions) = do - let variableNames = sequentialNetworkVariableNaming "X_" "Y_" variables - let variableNamesMap = Map.fromList (zip variables variableNames) - variableDocs <- forM variableNames compileVariable - assertionDocs <- forM assertions (compileAssertion variableNamesMap) +compileVNNLibQuery :: (MonadLogger m) => QueryAddress -> QueryContents -> m QueryText +compileVNNLibQuery _address (QueryContents variables assertions) = do + variableDocs <- forM variables compileVariableDecl + assertionDocs <- forM assertions compileAssertion let assertionsDoc = vsep assertionDocs <> line <> vsep variableDocs return $ layoutAsText assertionsDoc -compileVariable :: (MonadLogger m) => Name -> m (Doc a) -compileVariable varName = return $ parens ("declare-fun" <+> pretty varName <+> "() Real") - -compileAssertion :: - (MonadLogger m) => - Map NetworkVariable Name -> - Assertion NetworkVariable -> - m (Doc a) -compileAssertion varNames assertion = do - let (coeffVars, rel, constant) = convertToSparseFormat varNames assertion +compileVariableDecl :: (MonadLogger m) => NetworkRationalVariable -> m (Doc a) +compileVariableDecl var = return $ parens ("declare-fun" <+> compileVar var <+> "() Real") +compileAssertion :: (MonadLogger m) => QueryAssertion -> m (Doc a) +compileAssertion QueryAssertion {..} = do let compiledRel = compileRel rel - let compiledLHS = foldl compileVar "" (NonEmpty.tail coeffVars) - let compiledRHS = prettyRationalAsFloat constant + let compiledLHS = foldl compileCoefVar "" (NonEmpty.tail lhs) + let compiledRHS = prettyRationalAsFloat rhs return $ parens "assert" <+> parens (compiledRel <+> parens compiledLHS <+> compiledRHS) -compileRel :: Either EqualityOp OrderOp -> Doc a +compileRel :: QueryRelation -> Doc a compileRel = \case - Left Eq -> "==" - Left Neq -> "==" - Right Le -> "<=" - Right Ge -> ">=" - Right Lt -> "<" - Right Gt -> ">" + EqualRel -> "==" + OrderRel Le -> "<=" + OrderRel Ge -> ">=" + OrderRel Lt -> "<" + OrderRel Gt -> ">" -compileVar :: Doc a -> (Coefficient, Name) -> Doc a -compileVar r (coef, var) +compileCoefVar :: Doc a -> (Coefficient, NetworkRationalVariable) -> Doc a +compileCoefVar r (coef, var) | coef == 1 = "+" <+> parens r <+> pretty var | coef == -1 = "-" <+> parens r <+> pretty var | coef < 0 = "-" <+> parens r <+> parens ("*" <+> prettyRationalAsFloat (-coef) <+> pretty var) | otherwise = "+" <+> parens r <+> parens ("*" <+> prettyRationalAsFloat coef <+> pretty var) + +compileVar :: NetworkRationalVariable -> Doc a +compileVar var = do + let name = if inputOrOutput (originalVar var) == Input then "X" else "Y" + let index = computeAbsoluteIndex var + name <> "_" <> pretty index diff --git a/vehicle/src/Vehicle/Verify/Specification.hs b/vehicle/src/Vehicle/Verify/Specification.hs index 85128a4b9..fdda0f165 100644 --- a/vehicle/src/Vehicle/Verify/Specification.hs +++ b/vehicle/src/Vehicle/Verify/Specification.hs @@ -19,8 +19,8 @@ where import Data.Aeson (FromJSON, ToJSON) import GHC.Generics (Generic) +import Vehicle.Backend.Queries.UserVariableElimination.Core import Vehicle.Data.BooleanExpr -import Vehicle.Prelude import Vehicle.Resource (ResourcesIntegrityInfo) import Vehicle.Syntax.AST (Name) import Vehicle.Verify.Core @@ -28,9 +28,10 @@ import Vehicle.Verify.Core -------------------------------------------------------------------------------- -- Query meta data -data QueryMetaData = QueryData - { metaNetwork :: MetaNetwork, - variableReconstruction :: VariableNormalisationSteps +data QueryMetaData = QueryMetaData + { queryAddress :: QueryAddress, + metaNetwork :: MetaNetwork, + variableReconstruction :: UserVariableReconstruction } deriving (Show, Generic) @@ -38,16 +39,17 @@ instance ToJSON QueryMetaData instance FromJSON QueryMetaData +{- instance Pretty QueryMetaData where - pretty (QueryData metaNetwork _userVar) = + pretty (QueryMetaData _ metaNetwork _userVar) = "Meta-network:" <+> pretty metaNetwork - +-} -------------------------------------------------------------------------------- -- Query set data QuerySet a = QuerySet { negated :: QuerySetNegationStatus, - queries :: DisjunctAll (QueryAddress, a) + queries :: DisjunctAll a } deriving (Show, Generic, Functor, Foldable, Traversable) @@ -57,11 +59,11 @@ instance (FromJSON a) => FromJSON (QuerySet a) traverseQuerySet :: (Monad m) => - ((QueryAddress, a) -> m b) -> + (a -> m b) -> QuerySet a -> m (QuerySet b) traverseQuerySet f QuerySet {..} = do - queries' <- traverse (\(address, query) -> (address,) <$> f (address, query)) queries + queries' <- traverse f queries return $ QuerySet negated queries' querySetSize :: QuerySet a -> Int @@ -81,25 +83,15 @@ type Property a = MaybeTrivial (BooleanExpr (QuerySet a)) traverseProperty :: forall m a b. (Monad m) => - ((QueryAddress, a) -> m b) -> + (a -> m b) -> Property a -> m (Property b) -traverseProperty f = \case - Trivial b -> return $ Trivial b - NonTrivial b -> NonTrivial <$> traverseBoolExpr b - where - traverseBoolExpr :: - BooleanExpr (QuerySet a) -> - m (BooleanExpr (QuerySet b)) - traverseBoolExpr = \case - Query qs -> Query <$> traverseQuerySet f qs - Disjunct x y -> Disjunct <$> traverseBoolExpr x <*> traverseBoolExpr y - Conjunct x y -> Conjunct <$> traverseBoolExpr x <*> traverseBoolExpr y +traverseProperty f = traverse (traverse (traverseQuerySet f)) forQueryInProperty :: (Monad m) => Property a -> - ((QueryAddress, a) -> m ()) -> + (a -> m ()) -> m () forQueryInProperty p f = do _ <- traverseProperty f p diff --git a/vehicle/src/Vehicle/Verify/Specification/IO.hs b/vehicle/src/Vehicle/Verify/Specification/IO.hs index 563460554..f4a27c162 100644 --- a/vehicle/src/Vehicle/Verify/Specification/IO.hs +++ b/vehicle/src/Vehicle/Verify/Specification/IO.hs @@ -34,14 +34,16 @@ import System.FilePath (takeExtension, (<.>), ()) import System.IO (stderr, stdout) import System.ProgressBar import Vehicle.Backend.Agda.Interact (writeResultToFile) -import Vehicle.Backend.Queries.Variable (UserVariable (..)) -import Vehicle.Backend.Queries.VariableReconstruction (reconstructUserVars) +import Vehicle.Backend.Queries.UserVariableElimination.VariableReconstruction (reconstructUserVars) import Vehicle.Compile.Prelude import Vehicle.Data.BooleanExpr +import Vehicle.Data.LinearExpr (RationalTensor (..)) +import Vehicle.Prelude.IO qualified as VIO (MonadStdIO (writeStdoutLn)) import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat import Vehicle.Verify.Specification import Vehicle.Verify.Specification.Status +import Vehicle.Verify.Variable (OriginalUserVariable (..), UserVariableAssignment (..)) import Vehicle.Verify.Verifier -------------------------------------------------------------------------------- @@ -169,14 +171,14 @@ readPropertyVerificationPlan planFile = do Just plan -> return plan writeVerificationQuery :: - (MonadLogger m, MonadIO m) => + (MonadLogger m, MonadIO m, MonadStdIO m) => QueryFormat -> FilePath -> - (QueryAddress, QueryText) -> + (QueryMetaData, QueryText) -> m () -writeVerificationQuery queryFormat folder (queryAddress, queryText) = do +writeVerificationQuery queryFormat folder (queryMetaData, queryText) = do let queryOutputForm = queryOutputFormat queryFormat - let queryFilePath = folder calculateQueryFileName queryAddress + let queryFilePath = folder calculateQueryFileName (queryAddress queryMetaData) writeResultToFile (Just queryOutputForm) (Just queryFilePath) (pretty queryText) writePropertyResult :: @@ -225,7 +227,8 @@ propertyResultFileName folder propertyAddress = type MonadVerify m = ( MonadLogger m, - MonadIO m + MonadIO m, + MonadStdIO m ) type MonadVerifyProperty m = @@ -298,16 +301,24 @@ verifyPropertyBooleanStructure = \case m (QuerySetNegationStatus, QueryResult UserVariableAssignment) go = \case Query qs -> verifyQuerySet qs - Disjunct x y -> do - result@(negated, status) <- go x - if evaluateQuery negated status - then return result - else go y - Conjunct x y -> do - result@(negated, status) <- go x - if not (evaluateQuery negated status) - then return result - else go y + Disjunct (DisjunctAll xs) -> goDisjunct xs + Conjunct (ConjunctAll xs) -> goConjunct xs + + goConjunct :: NonEmpty (BooleanExpr (QuerySet QueryMetaData)) -> m (QuerySetNegationStatus, QueryResult UserVariableAssignment) + goConjunct (x :| []) = go x + goConjunct (x :| y : ys) = do + result@(negated, status) <- go x + if not (evaluateQuery negated status) + then return result + else goConjunct (y :| ys) + + goDisjunct :: NonEmpty (BooleanExpr (QuerySet QueryMetaData)) -> m (QuerySetNegationStatus, QueryResult UserVariableAssignment) + goDisjunct (x :| []) = go x + goDisjunct (x :| y : ys) = do + result@(negated, status) <- go x + if evaluateQuery negated status + then return result + else goDisjunct (y :| ys) verifyQuerySet :: (MonadVerifyProperty m) => @@ -320,12 +331,12 @@ verifyQuerySet (QuerySet negated disjuncts) = do verifyDisjunctAll :: forall m. (MonadVerifyProperty m) => - DisjunctAll (QueryAddress, QueryMetaData) -> + DisjunctAll QueryMetaData -> m (QueryResult UserVariableAssignment) verifyDisjunctAll (DisjunctAll ys) = go ys where go :: - NonEmpty (QueryAddress, QueryMetaData) -> + NonEmpty QueryMetaData -> m (QueryResult UserVariableAssignment) go (x :| []) = verifyQuery x go (x :| y : xs) = do @@ -336,9 +347,9 @@ verifyDisjunctAll (DisjunctAll ys) = go ys verifyQuery :: (MonadVerifyProperty m) => - (QueryAddress, QueryMetaData) -> + QueryMetaData -> m (QueryResult UserVariableAssignment) -verifyQuery (queryAddress, QueryData metaNetwork userVar) = do +verifyQuery (QueryMetaData queryAddress metaNetwork userVar) = do tell (Sum 1) (verifier, verifierExecutable, folder, progressBar) <- ask let queryFile = folder calculateQueryFileName queryAddress @@ -349,19 +360,19 @@ verifyQuery (queryAddress, QueryData metaNetwork userVar) = do exitFailure Right result -> do liftIO $ incProgress progressBar 1 - traverse (reconstructUserVars metaNetwork userVar) result + traverse (reconstructUserVars userVar) result -------------------------------------------------------------------------------- -- Assignments outputPropertyResult :: - (MonadIO m) => + (MonadIO m, MonadStdIO m) => FilePath -> PropertyAddress -> PropertyStatus -> m () outputPropertyResult verificationCache address result@(PropertyStatus status) = do - liftIO $ TIO.putStrLn (layoutAsText $ " result: " <> pretty result) + VIO.writeStdoutLn (layoutAsText $ " result: " <> pretty result) writePropertyResult verificationCache address (isVerified result) case status of NonTrivial (_, SAT (Just (UserVariableAssignment assignments))) -> do @@ -373,9 +384,9 @@ outputPropertyResult verificationCache address result@(PropertyStatus status) = -- Output assignments to file let witnessFolder = verificationCache layoutAsString (pretty address) <> "-assignments" liftIO $ createDirectoryIfMissing True witnessFolder - forM_ assignments $ \(UserVariable {..}, value) -> do - let file = witnessFolder unpack userVarName - let dims = Vector.fromList userVarDimensions + forM_ assignments $ \(var, RationalTensor varDims value) -> do + let file = witnessFolder unpack (userTensorVarName var) + let dims = Vector.fromList varDims -- TODO got to be a better way to do this conversion... let unboxedVector = Vector.fromList $ BoxedVector.toList (fmap realToFrac value) let idxData = IDXDoubles IDXDouble dims unboxedVector @@ -388,7 +399,7 @@ outputPropertyResult verificationCache address result@(PropertyStatus status) = type PropertyProgressBar = ProgressBar () createPropertyProgressBar :: (MonadIO m) => PropertyAddress -> Int -> m PropertyProgressBar -createPropertyProgressBar (PropertyAddress name indices) numberOfQueries = do +createPropertyProgressBar (PropertyAddress _ name indices) numberOfQueries = do let propertyName = LazyText.fromStrict $ intercalate "!" (name : fmap (pack . show) indices) let style = defStyle @@ -399,5 +410,5 @@ createPropertyProgressBar (PropertyAddress name indices) numberOfQueries = do let initialProgress = Progress 0 numberOfQueries () liftIO $ hNewProgressBar stdout style 10 initialProgress -closePropertyProgressBar :: (MonadIO m) => PropertyProgressBar -> m () -closePropertyProgressBar _progressBar = liftIO $ putStrLn "" +closePropertyProgressBar :: (MonadIO m, MonadStdIO m) => PropertyProgressBar -> m () +closePropertyProgressBar _progressBar = VIO.writeStdoutLn "" diff --git a/vehicle/src/Vehicle/Verify/Specification/Status.hs b/vehicle/src/Vehicle/Verify/Specification/Status.hs index 625e68cfe..b1259013f 100644 --- a/vehicle/src/Vehicle/Verify/Specification/Status.hs +++ b/vehicle/src/Vehicle/Verify/Specification/Status.hs @@ -3,17 +3,16 @@ module Vehicle.Verify.Specification.Status where import Data.Aeson import Data.List.Split (chunksOf) import Data.Text (Text, pack) -import Data.Vector qualified as Vector import GHC.Generics (Generic) import System.Console.ANSI (Color (..)) -import Vehicle.Backend.Queries.Variable import Vehicle.Compile.Prelude -import Vehicle.Compile.Print (prettyFriendlyEmptyCtx) import Vehicle.Compile.Type.Subsystem.Standard.Core import Vehicle.Data.BooleanExpr (MaybeTrivial (..)) -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr +import Vehicle.Data.LinearExpr (RationalTensor) import Vehicle.Verify.Core import Vehicle.Verify.Specification +import Vehicle.Verify.Variable class IsVerified a where isVerified :: a -> Bool @@ -61,7 +60,7 @@ type MultiPropertyStatus = MultiProperty PropertyStatus instance IsVerified MultiPropertyStatus where isVerified = \case - MultiProperty ps -> and (fmap isVerified ps) + MultiProperty ps -> all isVerified ps SingleProperty _ status -> isVerified status nameSubProperties :: Name -> [MultiPropertyStatus] -> [(Name, MultiPropertyStatus)] @@ -88,12 +87,9 @@ prettyNameAndStatus :: Text -> Bool -> Doc a prettyNameAndStatus name verified = do pretty (statusSymbol verified) <+> pretty name -prettyUserVariableAssignment :: (UserVariable, VariableValue) -> Doc a -prettyUserVariableAssignment (UserVariable {..}, variableValue) = do - let name = pretty userVarName - let valueExpr = assignmentToExpr userVarDimensions (Vector.toList variableValue) - let value = prettyFriendlyEmptyCtx valueExpr - name <> ":" <+> value +prettyUserVariableAssignment :: (OriginalUserVariable, RationalTensor) -> Doc a +prettyUserVariableAssignment (OriginalUserVariable {..}, variableValue) = + pretty userTensorVarName <> ":" <+> pretty variableValue assignmentToExpr :: TensorDimensions -> [Rational] -> Expr Ix Builtin assignmentToExpr [] xs = RatLiteral mempty (toRational (head xs)) @@ -110,7 +106,7 @@ type SpecificationStatus = Specification PropertyStatus instance IsVerified SpecificationStatus where isVerified (Specification properties) = - and (fmap (isVerified . snd) properties) + all (isVerified . snd) properties instance Pretty SpecificationStatus where pretty spec@(Specification properties) = do diff --git a/vehicle/src/Vehicle/Verify/Variable.hs b/vehicle/src/Vehicle/Verify/Variable.hs new file mode 100644 index 000000000..7ac489eaa --- /dev/null +++ b/vehicle/src/Vehicle/Verify/Variable.hs @@ -0,0 +1,240 @@ +module Vehicle.Verify.Variable where + +import Data.Aeson (FromJSON, FromJSONKey, ToJSON, ToJSONKey) +import Data.Char.SScript +import Data.Hashable (Hashable) +import Data.Map (Map) +import Data.Map qualified as Map +import GHC.Generics (Generic) +import Numeric (showFFloat) +import Prettyprinter (brackets) +import Vehicle.Data.BuiltinInterface.Value +import Vehicle.Data.DeBruijn +import Vehicle.Data.LinearExpr +import Vehicle.Data.NormalisedExpr +import Vehicle.Prelude +import Vehicle.Syntax.AST +import Vehicle.Syntax.Builtin + +-------------------------------------------------------------------------------- +-- User tensor variables + +data OriginalUserVariable = OriginalUserVariable + { userTensorVarName :: Name, + userTensorVarDimensions :: TensorDimensions + } + deriving (Show, Eq, Ord, Generic) + +instance ToJSON OriginalUserVariable + +instance FromJSON OriginalUserVariable + +instance Hashable OriginalUserVariable + +instance Pretty OriginalUserVariable where + pretty = pretty . userTensorVarName + +-------------------------------------------------------------------------------- +-- Network tensor variables + +-- | Network input and output variables +data OriginalNetworkVariable = OriginalNetworkVariable + { -- | The name of the network this variable belongs to. + networkName :: Name, + -- | Whether its an input or an output variable + inputOrOutput :: InputOrOutput, + -- | The dimensions of the variable + networkTensorVarDimensions :: TensorDimensions, + -- | The position in the list of applications of `networkName` + application :: Int, + -- | Index starting + startingIndex :: Int + } + deriving (Show, Eq, Ord, Generic) + +instance ToJSON OriginalNetworkVariable + +instance FromJSON OriginalNetworkVariable + +instance Hashable OriginalNetworkVariable + +instance Pretty OriginalNetworkVariable where + pretty OriginalNetworkVariable {..} = + pretty networkName + <> pretty (fmap subscript (show application)) + <> brackets (pretty inputOrOutput) + +-------------------------------------------------------------------------------- +-- Reduced variables + +data ReducedVariable variable = ReducedVariable + { originalVar :: variable, + tensorIndices :: TensorIndices + } + deriving (Show, Eq, Ord, Generic) + +instance (Pretty variable) => Pretty (ReducedVariable variable) where + pretty ReducedVariable {..} = + pretty originalVar <> pretty (showTensorIndices tensorIndices) + +instance (FromJSON variable) => FromJSON (ReducedVariable variable) + +instance (FromJSON variable) => FromJSONKey (ReducedVariable variable) + +instance (ToJSON variable) => ToJSON (ReducedVariable variable) + +instance (ToJSON variable) => ToJSONKey (ReducedVariable variable) + +instance (Hashable variable) => Hashable (ReducedVariable variable) + +reduceVariable :: + forall variable. + (variable -> TensorDimensions) -> + Lv -> + variable -> + ([(Lv, ReducedVariable variable)], WHNFValue Builtin) +reduceVariable varDims dbLevel var + | null (varDims var) = createRatVar [] dbLevel + | otherwise = do + let (vars, expr) = runSupply (go (varDims var) []) [dbLevel ..] + (reverse vars, expr) + where + createRatVar :: TensorIndices -> Lv -> ([(Lv, ReducedVariable variable)], WHNFValue Builtin) + createRatVar indices lv = ([(lv, ReducedVariable var indices)], VBoundVar lv []) + + go :: + TensorDimensions -> + TensorIndices -> + Supply Lv ([(Lv, ReducedVariable variable)], WHNFValue Builtin) + go dims indices = case dims of + [] -> createRatVar (reverse indices) <$> demand + d : ds -> do + -- Use the list monad to create a nested list of all possible indices into the tensor + let allIndices = [0 .. d - 1] + + -- Generate the corresponding names from the indices + (elementUserVars, subexprs) <- unzip <$> traverse (\i -> go ds (i : indices)) allIndices + let userVars = concat elementUserVars + return (userVars, mkVLVec subexprs) + +-------------------------------------------------------------------------------- +-- Reduced user variables + +-- | Variables entered by the user +type UserRationalVariable = ReducedVariable OriginalUserVariable + +type NetworkRationalVariable = ReducedVariable OriginalNetworkVariable + +computeAbsoluteIndex :: NetworkRationalVariable -> Int +computeAbsoluteIndex ReducedVariable {..} = do + let offset = startingIndex originalVar + offset + computeFlatIndex (networkTensorVarDimensions originalVar) tensorIndices + +-------------------------------------------------------------------------------- +-- All variables + +-- | Both user and network variables +data RationalVariable + = UserRationalVar UserRationalVariable + | NetworkRationalVar NetworkRationalVariable + deriving (Show, Eq, Ord, Generic) + +instance ToJSON RationalVariable + +instance FromJSON RationalVariable + +instance ToJSONKey RationalVariable + +instance FromJSONKey RationalVariable + +instance Pretty RationalVariable where + pretty = \case + UserRationalVar v -> pretty v + NetworkRationalVar v -> pretty v + +-------------------------------------------------------------------------------- +-- Tensor variables + +-- | Both user and network variables +data TensorVariable + = UserTensorVar OriginalUserVariable + | NetworkTensorVar OriginalNetworkVariable + deriving (Show, Eq, Ord, Generic) + +instance ToJSON TensorVariable + +instance FromJSON TensorVariable + +instance ToJSONKey TensorVariable + +instance FromJSONKey TensorVariable + +instance Pretty TensorVariable where + pretty = \case + UserTensorVar v -> pretty v + NetworkTensorVar v -> pretty v + +tensorVariableDims :: TensorVariable -> TensorDimensions +tensorVariableDims = \case + UserTensorVar v -> userTensorVarDimensions v + NetworkTensorVar v -> networkTensorVarDimensions v + +-------------------------------------------------------------------------------- +-- Tensor variables + +-- | Both user and network variables +data Variable + = RationalVar RationalVariable + | TensorVar TensorVariable + deriving (Show, Eq, Ord, Generic) + +instance ToJSON Variable + +instance FromJSON Variable + +instance ToJSONKey Variable + +instance FromJSONKey Variable + +instance Pretty Variable where + pretty = \case + RationalVar v -> pretty v + TensorVar v -> pretty v + +-------------------------------------------------------------------------------- +-- Constants + +prettyRationalAsFloat :: Rational -> Doc a +prettyRationalAsFloat p = do + let f = realToFrac p :: Double + pretty $ showFFloat Nothing f "" + +-------------------------------------------------------------------------------- +-- Network assignments + +-- | A (satisfying) assignment to a set of reduced network-level variables. +newtype NetworkVariableAssignment + = NetworkVariableAssignment (Map NetworkRationalVariable Rational) + +instance Pretty NetworkVariableAssignment where + pretty (NetworkVariableAssignment assignment) = do + vsep (prettyVariable <$> Map.toList assignment) + where + prettyVariable :: (NetworkRationalVariable, Rational) -> Doc a + prettyVariable (var, value) = "x" <> pretty var <> ":" <+> pretty value + +-------------------------------------------------------------------------------- +-- User variable assignments + +-- | A (satisfying) assignment to a set of user-level variables. +newtype UserVariableAssignment + = UserVariableAssignment [(OriginalUserVariable, RationalTensor)] + deriving (Generic) + +instance ToJSON UserVariableAssignment + +instance FromJSON UserVariableAssignment + +instance Pretty UserVariableAssignment where + pretty :: UserVariableAssignment -> Doc a + pretty (UserVariableAssignment assignment) = vsep (fmap pretty assignment) diff --git a/vehicle/src/Vehicle/Verify/Verifier/Core.hs b/vehicle/src/Vehicle/Verify/Verifier/Core.hs index 4dca8ffff..c23deb437 100644 --- a/vehicle/src/Vehicle/Verify/Verifier/Core.hs +++ b/vehicle/src/Vehicle/Verify/Verifier/Core.hs @@ -5,6 +5,7 @@ import Data.Text (Text) import Vehicle.Compile.Prelude import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat.Core +import Vehicle.Verify.Variable -------------------------------------------------------------------------------- -- Verifiers diff --git a/vehicle/src/Vehicle/Verify/Verifier/Marabou.hs b/vehicle/src/Vehicle/Verify/Verifier/Marabou.hs index 900c4142a..ff593e3e2 100644 --- a/vehicle/src/Vehicle/Verify/Verifier/Marabou.hs +++ b/vehicle/src/Vehicle/Verify/Verifier/Marabou.hs @@ -5,16 +5,19 @@ where import Control.Monad.IO.Class (MonadIO (..)) import Data.List (elemIndex, findIndex) +import Data.Map (Map) +import Data.Map qualified as Map import Data.Text (Text) import Data.Text qualified as Text (pack, splitOn, strip) import Data.Text.IO (hPutStrLn) -import Data.Vector qualified as Vector import System.Exit (ExitCode (..), exitFailure) import System.IO (stderr) import System.Process (readProcessWithExitCode) import Vehicle.Compile.Prelude import Vehicle.Verify.Core import Vehicle.Verify.QueryFormat.Core +import Vehicle.Verify.QueryFormat.Marabou (compileVar) +import Vehicle.Verify.Variable import Vehicle.Verify.Verifier.Core -------------------------------------------------------------------------------- @@ -33,9 +36,9 @@ marabouVerifier = -- Invoking Marabou invokeMarabou :: VerifierInvocation -invokeMarabou marabouExecutable networkLocations queryFile = do +invokeMarabou marabouExecutable metaNetwork queryFile = do -- Prepare arguments - networkArg <- prepareNetworkArg networkLocations + networkArg <- prepareNetworkArg (networkEntries metaNetwork) let args = [networkArg, queryFile] let command = unwords (marabouExecutable : args) @@ -45,10 +48,10 @@ invokeMarabou marabouExecutable networkLocations queryFile = do -- Parse result logDebug MaxDetail $ "Output of verify command: " <> line <> indent 2 (pretty out) - parseMarabouOutput command (exitCode, out, err) + parseMarabouOutput metaNetwork command (exitCode, out, err) -prepareNetworkArg :: (MonadIO m) => MetaNetwork -> m String -prepareNetworkArg [MetaNetworkEntry {..}] = return metaNetworkEntryFilePath +prepareNetworkArg :: (MonadIO m) => [MetaNetworkEntry] -> m String +prepareNetworkArg [MetaNetworkEntry {..}] = return (networkFilepath metaNetworkEntryInfo) prepareNetworkArg metaNetwork = do let duplicateNetworkNames = findDuplicates (fmap metaNetworkEntryName metaNetwork) @@ -70,10 +73,11 @@ prepareNetworkArg metaNetwork = do parseMarabouOutput :: (MonadIO m) => + MetaNetwork -> String -> (ExitCode, String, String) -> m (Either Text (QueryResult NetworkVariableAssignment)) -parseMarabouOutput command (exitCode, out, _err) = case exitCode of +parseMarabouOutput metaNetwork command (exitCode, out, _err) = case exitCode of ExitFailure exitValue | exitValue < 0 -> do -- Marabou was killed by the system. @@ -102,37 +106,45 @@ parseMarabouOutput command (exitCode, out, _err) = case exitCode of let outputLines = fmap Text.pack (lines out) let resultIndex = findIndex (\v -> v == "sat" || v == "unsat") outputLines case resultIndex of - Nothing -> malformedOutputError "cannot find 'sat' or 'unsat'" + Nothing -> malformedOutwriteStderror "cannot find 'sat' or 'unsat'" Just i | outputLines !! i == "unsat" -> return $ Right UnSAT | otherwise -> do let assignmentOutput = drop (i + 1) outputLines - ioVarAssignment <- parseSATAssignment (filter (/= "") assignmentOutput) + ioVarAssignment <- parseSATAssignment metaNetwork (filter (/= "") assignmentOutput) return $ Right $ SAT $ Just ioVarAssignment -parseSATAssignment :: (MonadIO m) => [Text] -> m NetworkVariableAssignment -parseSATAssignment output = do +parseSATAssignment :: (MonadIO m) => MetaNetwork -> [Text] -> m NetworkVariableAssignment +parseSATAssignment metaNetwork output = do + let variableMap = Map.fromList $ fmap (\var -> (layoutAsText $ compileVar var, var)) (variables metaNetwork) let mInputIndex = elemIndex "Input assignment:" output let mOutputIndex = elemIndex "Output:" output case (mInputIndex, mOutputIndex) of (Just inputIndex, Just outputIndex) -> do let inputVarLines = take (outputIndex - inputIndex - 1) $ drop (inputIndex + 1) output let outputVarLines = drop (outputIndex + 1) output - let inputValues = parseSATAssignmentLine Input <$> inputVarLines - let outputValues = parseSATAssignmentLine Output <$> outputVarLines - return $ NetworkVariableAssignment $ Vector.fromList (inputValues <> outputValues) - _ -> malformedOutputError "could not find strings 'Input assignment:' and 'Output:'" + let values = parseSATAssignmentLine variableMap <$> (inputVarLines <> outputVarLines) + return $ NetworkVariableAssignment $ Map.fromList values + _ -> malformedOutwriteStderror "could not find strings 'Input assignment:' and 'Output:'" -parseSATAssignmentLine :: InputOrOutput -> Text -> Rational -parseSATAssignmentLine _ txt = +parseSATAssignmentLine :: + Map Text NetworkRationalVariable -> + Text -> + (NetworkRationalVariable, Rational) +parseSATAssignmentLine varsByName txt = let parts = Text.strip <$> Text.splitOn "=" txt in case parts of - [_namePart, valuePart] -> readFloatAsRational valuePart + [namePart, valuePart] -> do + let var = case Map.lookup namePart varsByName of + Just v -> v + Nothing -> malformedOutwriteStderror $ "could not parse variable" <+> quotePretty namePart + let value = readFloatAsRational valuePart + (var, value) _ -> - malformedOutputError $ - "could not split assignment line" <+> squotes (pretty txt) <+> "on '=' sign" + malformedOutwriteStderror $ + "could not split assignment line" <+> quotePretty txt <+> "on '=' sign" -malformedOutputError :: Doc a -> b -malformedOutputError x = +malformedOutwriteStderror :: Doc a -> b +malformedOutwriteStderror x = error $ layoutAsString ("Unexpected output from Marabou..." <+> x) diff --git a/vehicle/tests/golden/compile/acasXu/Agda.agda.golden b/vehicle/tests/golden/compile/acasXu/Agda.agda.golden index 445ba6245..1dee93e23 100644 --- a/vehicle/tests/golden/compile/acasXu/Agda.agda.golden +++ b/vehicle/tests/golden/compile/acasXu/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.err.golden b/vehicle/tests/golden/compile/acasXu/Marabou.err.golden index 9f2c2d715..b34cbded9 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.err.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.err.golden @@ -1,33 +1,33 @@  -Warning: While compiling property 'property1', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'property1', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: While compiling property 'property2', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + + +Warning: In property 'property2', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: While compiling property 'property3', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + + +Warning: In property 'property3', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: While compiling property 'property4', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + + +Warning: In property 'property4', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: While compiling property 'property7', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + + +Warning: In property 'property7', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1-query1.txt.golden index 02dae57ca..83a0ce970 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1-query1.txt.golden @@ -2,18 +2,18 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= 0.6 -x0 <= 0.6715771228489404 -x1 >= -0.5 x1 <= 0.5 -x2 >= -0.5 +x1 >= -0.5 x2 <= 0.5 +x2 >= -0.5 +x3 <= 0.5 x3 >= -0.5 x3 >= 0.45 -x3 <= 0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.45 +x4 <= 0.5 +x4 >= -0.5 y0 >= 3.9911256459153677 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1.vcl-plan.golden index 0bc81f515..3f515d357 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property1.vcl-plan.golden @@ -6,322 +6,529 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property1", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property1", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query1.txt.golden index 7889eeb06..8c98a6c19 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query1.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y1 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= 0.26897842717512155 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 -x3 >= -0.5 -x3 >= 0.22727272727272727 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= 0.22727272727272727 x4 <= 0.5 x4 <= 0.5 --y0 +y1 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query2.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query2.txt.golden index 419be776c..1f5b3d111 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query2.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query2.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= 0.26897842717512155 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 -x3 >= -0.5 -x3 >= 0.22727272727272727 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= 0.22727272727272727 x4 <= 0.5 x4 <= 0.5 --y0 +y2 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query3.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query3.txt.golden index ea64281dd..641a1f2a9 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query3.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query3.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= 0.26897842717512155 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 -x3 >= -0.5 -x3 >= 0.22727272727272727 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= 0.22727272727272727 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query4.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query4.txt.golden index c530f3bcb..9cf743aa3 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query4.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10-query4.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= 0.26897842717512155 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 -x3 >= -0.5 -x3 >= 0.22727272727272727 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= 0.22727272727272727 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10.vcl-plan.golden index 898ff4456..6262709ce 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property10.vcl-plan.golden @@ -6,1270 +6,2098 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property10", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property10", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 9 }, - 2 + 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property10", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 9 }, - 3 + 2 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property10", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 9 }, - 4 + 3 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property10", + "propertyIndices": [], + "propertyID": 9 + }, + 4 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2-query1.txt.golden index c2475cefc..6d47640de 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2-query1.txt.golden @@ -2,21 +2,21 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y1 <= 0.0 +-y0 +y2 <= 0.0 +-y0 +y3 <= 0.0 +-y0 +y4 <= 0.0 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= 0.6 -x0 <= 0.6715771228489404 -x1 >= -0.5 x1 <= 0.5 -x2 >= -0.5 +x1 >= -0.5 x2 <= 0.5 +x2 >= -0.5 +x3 <= 0.5 x3 >= -0.5 x3 >= 0.45 -x3 <= 0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.45 --y0 +y1 <= 0.0 --y0 +y2 <= 0.0 --y0 +y3 <= 0.0 --y0 +y4 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2.vcl-plan.golden index e85cc0de5..cedf1eb22 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property2.vcl-plan.golden @@ -6,322 +6,529 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property2", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property2", + "propertyIndices": [], + "propertyID": 1 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3-query1.txt.golden index 318fe343f..47139eae7 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3-query1.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y1 <= 0.0 ++y0 -y2 <= 0.0 ++y0 -y3 <= 0.0 ++y0 -y4 <= 0.0 +x0 <= -0.29855281193475053 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.30353115613746867 -x0 <= 0.6715771228489404 -x0 <= -0.29855281193475053 +x1 <= 0.009549298572188877 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.009549298572188877 -x1 <= 0.5 -x1 <= 0.009549298572188877 +x2 <= 0.5 x2 >= -0.5 x2 >= 0.4933804262297587 -x2 <= 0.5 +x3 <= 0.5 x3 >= -0.5 x3 >= 0.3 -x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.3 x4 <= 0.5 -+y0 -y1 <= 0.0 -+y0 -y2 <= 0.0 -+y0 -y3 <= 0.0 -+y0 -y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.3 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3.vcl-plan.golden index 6850463e3..8ab110455 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property3.vcl-plan.golden @@ -6,322 +6,529 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property3", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property3", + "propertyIndices": [], + "propertyID": 2 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4-query1.txt.golden index 938626f33..266a74471 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4-query1.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y1 <= 0.0 ++y0 -y2 <= 0.0 ++y0 -y3 <= 0.0 ++y0 -y4 <= 0.0 +x0 <= -0.29855281193475053 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.30353115613746867 -x0 <= 0.6715771228489404 -x0 <= -0.29855281193475053 +x1 <= 0.009549298572188877 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.009549298572188877 -x1 <= 0.5 -x1 <= 0.009549298572188877 -x2 >= -0.5 -x2 <= 0.5 x2 = 0.0 +x2 <= 0.5 +x2 >= -0.5 +x3 <= 0.5 x3 >= -0.5 x3 >= 0.3181818181818182 -x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.08333333333333333 -x4 <= 0.5 x4 <= 0.16666666666666666 -+y0 -y1 <= 0.0 -+y0 -y2 <= 0.0 -+y0 -y3 <= 0.0 -+y0 -y4 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= 0.08333333333333333 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4.vcl-plan.golden index 272f334d4..e22342dc4 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property4.vcl-plan.golden @@ -6,322 +6,529 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property4", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property4", + "propertyIndices": [], + "propertyID": 3 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query1.txt.golden index 229217edc..b9529812c 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query1.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y4 <= 0.0 +x0 <= -0.3217850848807687 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.32427425698212775 -x0 <= 0.6715771228489404 -x0 <= -0.3217850848807687 +x1 <= 0.06366199048125919 +x1 <= 0.5 x1 >= -0.5 x1 >= 0.03183099524062959 -x1 <= 0.5 -x1 <= 0.06366199048125919 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 +x3 <= -0.22727272727272727 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.22727272727272727 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.16666666666666666 -+y0 -y4 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query2.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query2.txt.golden index 3e11d764b..cf0836f5a 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query2.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query2.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y1 -y4 <= 0.0 +x0 <= -0.3217850848807687 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.32427425698212775 -x0 <= 0.6715771228489404 -x0 <= -0.3217850848807687 +x1 <= 0.06366199048125919 +x1 <= 0.5 x1 >= -0.5 x1 >= 0.03183099524062959 -x1 <= 0.5 -x1 <= 0.06366199048125919 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 +x3 <= -0.22727272727272727 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.22727272727272727 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.16666666666666666 -+y1 -y4 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query3.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query3.txt.golden index 0515336a8..20d830079 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query3.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query3.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y4 <= 0.0 +x0 <= -0.3217850848807687 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.32427425698212775 -x0 <= 0.6715771228489404 -x0 <= -0.3217850848807687 +x1 <= 0.06366199048125919 +x1 <= 0.5 x1 >= -0.5 x1 >= 0.03183099524062959 -x1 <= 0.5 -x1 <= 0.06366199048125919 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 +x3 <= -0.22727272727272727 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.22727272727272727 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.16666666666666666 -+y2 -y4 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query4.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query4.txt.golden index b5ad6c7da..da0d1f47e 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query4.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5-query4.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y3 -y4 <= 0.0 +x0 <= -0.3217850848807687 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.32427425698212775 -x0 <= 0.6715771228489404 -x0 <= -0.3217850848807687 +x1 <= 0.06366199048125919 +x1 <= 0.5 x1 >= -0.5 x1 >= 0.03183099524062959 -x1 <= 0.5 -x1 <= 0.06366199048125919 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 +x3 <= -0.22727272727272727 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.22727272727272727 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.16666666666666666 -+y3 -y4 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5.vcl-plan.golden index f8b67f20c..596c6713a 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property5.vcl-plan.golden @@ -6,1270 +6,2098 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property5", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property5", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 4 }, - 2 + 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property5", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 4 }, - 3 + 2 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property5", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 4 }, - 4 + 3 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property5", + "propertyIndices": [], + "propertyID": 4 + }, + 4 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query1.txt.golden index 8c4f10c72..74a954131 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query1.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y1 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 +x1 <= -0.11140848334220357 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y1 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query2.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query2.txt.golden index d64c4b98f..6d7d91864 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query2.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query2.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 +x1 <= -0.11140848334220357 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y2 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query3.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query3.txt.golden index 1c5db7cc7..068934d2c 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query3.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query3.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 +x1 <= -0.11140848334220357 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query4.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query4.txt.golden index 19c63c74d..1a1f306f2 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query4.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query4.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 +x1 <= -0.11140848334220357 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query5.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query5.txt.golden index 09dd73232..6c7bf9e1a 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query5.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query5.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y1 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y1 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query6.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query6.txt.golden index 1915fffcb..8d1b7e874 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query6.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query6.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y2 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query7.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query7.txt.golden index 23df53f64..8d0528a78 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query7.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query7.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query8.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query8.txt.golden index 07b475e5a..dc62d5370 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query8.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6-query8.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.7004349247440301 x0 >= -0.32842287715105956 x0 >= -0.1292891090423325 -x0 <= 0.7004349247440301 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= 0.11140848334220357 x1 <= 0.5 x1 <= 0.5 +x1 >= -0.5 +x1 >= 0.11140848334220357 +x2 <= -0.49920422511898427 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49920422511898427 -x3 >= -0.5 -x3 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6.vcl-plan.golden index 78c198d82..9760ee79b 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property6.vcl-plan.golden @@ -6,2534 +6,4190 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property6", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property6", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 5 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property6", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 5 }, - 3 + 2 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property6", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 5 }, - 4 + 3 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property6", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 5 }, - 5 + 4 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property6", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 5 }, - 6 + 5 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property6", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 5 }, - 7 + 6 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property6", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 5 }, - 8 + 7 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property6", + "propertyIndices": [], + "propertyID": 5 + }, + 8 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query1.txt.golden index 0151aea82..6bcf87bc2 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query1.txt.golden @@ -2,28 +2,28 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y3 <= 0.0 +-y1 +y3 <= 0.0 +-y2 +y3 <= 0.0 ++y3 -y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= -0.5 x1 <= 0.5 x1 <= 0.5 -x2 >= -0.5 -x2 >= -0.5 +x1 >= -0.5 +x1 >= -0.5 x2 <= 0.5 x2 <= 0.5 -x3 >= -0.5 -x3 >= -0.5 +x2 >= -0.5 +x2 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 --y1 +y3 <= 0.0 --y2 +y3 <= 0.0 -+y3 -y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query2.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query2.txt.golden index 467f41269..b8889870d 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query2.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7-query2.txt.golden @@ -2,28 +2,28 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y4 <= 0.0 +-y1 +y4 <= 0.0 +-y2 +y4 <= 0.0 +-y3 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 -x1 >= -0.5 -x1 >= -0.5 x1 <= 0.5 x1 <= 0.5 -x2 >= -0.5 -x2 >= -0.5 +x1 >= -0.5 +x1 >= -0.5 x2 <= 0.5 x2 <= 0.5 -x3 >= -0.5 -x3 >= -0.5 +x2 >= -0.5 +x2 >= -0.5 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= -0.5 +x3 >= -0.5 +x3 >= -0.5 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 --y1 +y4 <= 0.0 --y2 +y4 <= 0.0 --y3 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7.vcl-plan.golden index 4542bf092..ba38136fc 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property7.vcl-plan.golden @@ -6,638 +6,1052 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property7", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property7", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 6 }, - 2 + 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property7", + "propertyIndices": [], + "propertyID": 6 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query1.txt.golden index 4f4e9aaac..9635057b9 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query1.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y1 <= 0.0 +-y0 +y1 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y1 <= 0.0 -+y0 -y1 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query10.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query10.txt.golden index 3894bceb0..f97aed189 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query10.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query10.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y2 <= 0.0 +-y1 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 --y1 +y2 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query11.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query11.txt.golden index f9a1ef277..7e0de0be6 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query11.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query11.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y3 <= 0.0 +-y1 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 --y1 +y3 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query12.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query12.txt.golden index 386878e6e..f74a9bf17 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query12.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query12.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y4 <= 0.0 +-y1 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 --y1 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query13.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query13.txt.golden index ec7988945..92fe6517d 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query13.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query13.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y1 <= 0.0 +-y1 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 -+y0 -y1 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query14.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query14.txt.golden index e45612229..83314e889 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query14.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query14.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y2 <= 0.0 +-y1 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 --y1 +y2 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query15.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query15.txt.golden index b30d1fe11..254706f17 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query15.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query15.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y3 <= 0.0 +-y1 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 --y1 +y3 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query16.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query16.txt.golden index 4ad3bf90e..2f62c295d 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query16.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query16.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y4 <= 0.0 +-y1 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y4 <= 0.0 --y1 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query2.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query2.txt.golden index a7eaa172f..fa56ba75c 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query2.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query2.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y1 <= 0.0 +-y0 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y1 <= 0.0 --y1 +y2 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query3.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query3.txt.golden index 4ecd39e4e..58408f697 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query3.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query3.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y1 <= 0.0 +-y0 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y1 <= 0.0 --y1 +y3 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query4.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query4.txt.golden index f093d9e90..6b00e492f 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query4.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query4.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y1 <= 0.0 +-y0 +y4 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y1 <= 0.0 --y1 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query5.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query5.txt.golden index 1c4b3b488..b4100f5d6 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query5.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query5.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y1 <= 0.0 +-y1 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y2 <= 0.0 -+y0 -y1 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query6.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query6.txt.golden index 52eba0bd2..f8b312480 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query6.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query6.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y2 <= 0.0 +-y1 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y2 <= 0.0 --y1 +y2 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query7.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query7.txt.golden index 00e4aeedc..50f3e8dfc 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query7.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query7.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y3 <= 0.0 +-y1 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y2 <= 0.0 --y1 +y3 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query8.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query8.txt.golden index 593302306..410ce98ba 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query8.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query8.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y4 <= 0.0 +-y1 +y2 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y2 <= 0.0 --y1 +y4 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query9.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query9.txt.golden index 95ee3c733..3885aa65b 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query9.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8-query9.txt.golden @@ -2,26 +2,26 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y1 <= 0.0 +-y1 +y3 <= 0.0 +x0 <= 0.6715771228489404 +x0 <= 0.6798577687061284 x0 >= -0.32842287715105956 x0 >= -0.32842287715105956 -x0 <= 0.6798577687061284 -x0 <= 0.6715771228489404 +x1 <= -0.375 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.5 -x1 <= 0.5 -x1 <= -0.375 +x2 <= 0.015915497620314797 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.015915497620314797 -x2 <= 0.5 -x2 <= 0.015915497620314797 -x3 >= -0.5 -x3 >= -0.045454545454545456 x3 <= 0.5 x3 <= 0.5 -x4 >= -0.5 -x4 >= 0.0 +x3 >= -0.5 +x3 >= -0.045454545454545456 x4 <= 0.5 x4 <= 0.5 --y0 +y3 <= 0.0 -+y0 -y1 <= 0.0 \ No newline at end of file +x4 >= -0.5 +x4 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8.vcl-plan.golden index 1d368974f..0ff875e26 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property8.vcl-plan.golden @@ -6,5062 +6,8374 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property8", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 3 + 2 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 4 + 3 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] } - }, - { - "numerator": 1200, - "denominator": 1 } - ] - ] - } - } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, { - "numerator": 650, - "denominator": 1 + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "baseType": [] + ] } }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 5 + 4 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 6 + 5 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] - ] - } - } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, { - "numerator": 0, + "numerator": 1, "denominator": 1 } + ] + ] + } + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 + } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 7 + 6 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 8 + 7 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] - ] - } - } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, { - "numerator": 0, + "numerator": 1, "denominator": 1 } + ] + ] + } + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 + } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 9 + 8 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 10 + 9 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 11 + 10 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 12 + 11 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ - { - "numerator": 600, - "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1200, - "denominator": 1 - } - ] - ] - } - } - ] + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "baseType": [] + ] } }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 13 + 12 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property8", + "propertyIndices": [], + "propertyID": 7 + }, + 13 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "property8", - "propertyIndices": [] - }, - 14 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 15 + 14 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property8", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 7 }, - 16 + 15 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property8", + "propertyIndices": [], + "propertyID": 7 + }, + 16 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query1.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query1.txt.golden index 8d0c10b15..557a603f5 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query1.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query1.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y0 -y3 <= 0.0 +x0 <= -0.21226151242096877 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.29523391579960506 -x0 <= 0.6715771228489404 -x0 <= -0.21226151242096877 +x1 <= -0.022281696668440713 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.06366199048125919 -x1 <= 0.5 -x1 <= -0.022281696668440713 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 +x3 <= -0.45454545454545453 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.45454545454545453 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.375 -+y0 -y3 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query2.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query2.txt.golden index 3eba0ed02..cc0ffdede 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query2.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query2.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y1 -y3 <= 0.0 +x0 <= -0.21226151242096877 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.29523391579960506 -x0 <= 0.6715771228489404 -x0 <= -0.21226151242096877 +x1 <= -0.022281696668440713 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.06366199048125919 -x1 <= 0.5 -x1 <= -0.022281696668440713 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 +x3 <= -0.45454545454545453 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.45454545454545453 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.375 -+y1 -y3 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query3.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query3.txt.golden index 436d1fff4..240cf666c 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query3.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query3.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y3 <= 0.0 +x0 <= -0.21226151242096877 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.29523391579960506 -x0 <= 0.6715771228489404 -x0 <= -0.21226151242096877 +x1 <= -0.022281696668440713 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.06366199048125919 -x1 <= 0.5 -x1 <= -0.022281696668440713 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 +x3 <= -0.45454545454545453 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.45454545454545453 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.375 -+y2 -y3 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query4.txt.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query4.txt.golden index e41755d2a..fdd4647aa 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query4.txt.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9-query4.txt.golden @@ -2,25 +2,25 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y3 +y4 <= 0.0 +x0 <= -0.21226151242096877 +x0 <= 0.6715771228489404 x0 >= -0.32842287715105956 x0 >= -0.29523391579960506 -x0 <= 0.6715771228489404 -x0 <= -0.21226151242096877 +x1 <= -0.022281696668440713 +x1 <= 0.5 x1 >= -0.5 x1 >= -0.06366199048125919 -x1 <= 0.5 -x1 <= -0.022281696668440713 +x2 <= -0.49840845023796854 +x2 <= 0.5 x2 >= -0.5 x2 >= -0.5 -x2 <= 0.5 -x2 <= -0.49840845023796854 +x3 <= -0.45454545454545453 +x3 <= 0.5 x3 >= -0.5 x3 >= -0.5 -x3 <= 0.5 -x3 <= -0.45454545454545453 -x4 >= -0.5 -x4 >= -0.5 -x4 <= 0.5 x4 <= -0.375 --y3 +y4 <= 0.0 \ No newline at end of file +x4 <= 0.5 +x4 >= -0.5 +x4 >= -0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9.vcl-plan.golden b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9.vcl-plan.golden index 774c1a823..ccd9af3b2 100644 --- a/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9.vcl-plan.golden +++ b/vehicle/tests/golden/compile/acasXu/Marabou.queries/property9.vcl-plan.golden @@ -6,1270 +6,2098 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "property9", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 + ] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, { - "numerator": 19791091, - "denominator": 1000 + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property9", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 8 }, - 2 + 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property9", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 8 }, - 3 + 2 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "property9", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 8 }, - 4 + 3 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "acasXu", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_4", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "acasXu", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 19791091, + "denominator": 60261000 + }, + "coefficients": [ + [ { - "numerator": 600, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 60261 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 4, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1200, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 650, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 3, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1100, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -62500, + "denominator": 392699 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 2, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 13, + "denominator": 22 + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1100 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 392699, - "denominator": 62500 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 19791091, - "denominator": 1000 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + } + }, + { + "numerator": -1, + "denominator": 1200 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], "networkName": "acasXu", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 60261, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "property9", + "propertyIndices": [], + "propertyID": 8 + }, + 4 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "acasXu", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "acasXu", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/andGate/Agda.agda.golden b/vehicle/tests/golden/compile/andGate/Agda.agda.golden index 2b64c8e02..d5f01e7d5 100644 --- a/vehicle/tests/golden/compile/andGate/Agda.agda.golden +++ b/vehicle/tests/golden/compile/andGate/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/andGate/Marabou.err.golden b/vehicle/tests/golden/compile/andGate/Marabou.err.golden index f6e3a12f0..6d2af6fc0 100644 --- a/vehicle/tests/golden/compile/andGate/Marabou.err.golden +++ b/vehicle/tests/golden/compile/andGate/Marabou.err.golden @@ -1,5 +1,5 @@  -Warning: While compiling property 'andGateCorrect', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'andGateCorrect', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). diff --git a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query1.txt.golden b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query1.txt.golden index 5cb862b63..459fbf8d1 100644 --- a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query1.txt.golden +++ b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query1.txt.golden @@ -2,11 +2,11 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x0 <= 1.0 x0 >= 0.0 x0 >= 0.5 -x0 <= 1.0 +x1 <= 1.0 x1 >= 0.0 x1 >= 0.5 -x1 <= 1.0 y0 <= 0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query2.txt.golden b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query2.txt.golden index b824c7fc7..17ecc8b8f 100644 --- a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query2.txt.golden +++ b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query2.txt.golden @@ -2,11 +2,11 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x0 <= 1.0 x0 >= 0.0 x0 >= 0.5 -x0 <= 1.0 -x1 >= 0.0 -x1 <= 1.0 x1 <= 0.5 +x1 <= 1.0 +x1 >= 0.0 y0 >= 0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query3.txt.golden b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query3.txt.golden index 43ee922b9..3f8c591bb 100644 --- a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query3.txt.golden +++ b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query3.txt.golden @@ -2,11 +2,11 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev -x0 >= 0.0 -x0 <= 1.0 +// - Vehicle version: 0.11.1+dev x0 <= 0.5 +x0 <= 1.0 +x0 >= 0.0 +x1 <= 1.0 x1 >= 0.0 x1 >= 0.5 -x1 <= 1.0 y0 >= 0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query4.txt.golden b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query4.txt.golden index 6d8327b11..9053331c2 100644 --- a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query4.txt.golden +++ b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect-query4.txt.golden @@ -2,11 +2,11 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev -x0 >= 0.0 -x0 <= 1.0 +// - Vehicle version: 0.11.1+dev x0 <= 0.5 -x1 >= 0.0 -x1 <= 1.0 +x0 <= 1.0 +x0 >= 0.0 x1 <= 0.5 +x1 <= 1.0 +x1 >= 0.0 y0 >= 0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect.vcl-plan.golden b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect.vcl-plan.golden index 57789ddd4..39e7b38f1 100644 --- a/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect.vcl-plan.golden +++ b/vehicle/tests/golden/compile/andGate/Marabou.queries/andGateCorrect.vcl-plan.golden @@ -6,714 +6,814 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "andGateCorrect", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x2", - "userVarDimensions": [], - "unreducedUserVarName": "x2" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x1", - "userVarDimensions": [], - "unreducedUserVarName": "x1" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "andGate", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "andGateCorrect", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 2 + 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "andGate", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x2", - "userVarDimensions": [], - "unreducedUserVarName": "x2" + "metaNetworkEntryName": "andGate", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x1", - "userVarDimensions": [], - "unreducedUserVarName": "x1" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "andGate", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "andGateCorrect", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 3 + 2 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } - } - }, + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "andGate", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x2", - "userVarDimensions": [], - "unreducedUserVarName": "x2" + "metaNetworkEntryName": "andGate", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x1", - "userVarDimensions": [], - "unreducedUserVarName": "x1" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "andGate", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "andGateCorrect", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 4 + 3 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "andGate", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "andGate", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "andGate", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x2", - "userVarDimensions": [], - "unreducedUserVarName": "x2" + "metaNetworkEntryName": "andGate", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x1", - "userVarDimensions": [], - "unreducedUserVarName": "x1" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "andGate", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "andGateCorrect", + "propertyIndices": [], + "propertyID": 0 + }, + 4 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "andGate", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "andGate", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "andGate", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/autoencoderError/Agda.agda.golden b/vehicle/tests/golden/compile/autoencoderError/Agda.agda.golden index 325956a2b..4b72d7b2a 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Agda.agda.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.err.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.err.golden index 1c3cdbf83..ba728a280 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.err.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.err.golden @@ -1,19 +1,18 @@  -Warning: While compiling property 'identity', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - decode₀[input]!0 - no constraints - decode₀[input]!1 - no constraints - encode₀[input]!0 - no constraints - encode₀[input]!1 - no constraints - encode₀[input]!2 - no constraints - encode₀[input]!3 - no constraints - encode₀[input]!4 - no constraints - - -Warning: While compiling property 'identity', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'identity', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'identity', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In queries 1, 2, 3, 4, 5, 6, 7, 8, 9 and 10: + decode₀[input]!0 - no lower or upper bound + decode₀[input]!1 - no lower or upper bound + encode₀[input]!0 - no lower or upper bound + encode₀[input]!1 - no lower or upper bound + encode₀[input]!2 - no lower or upper bound + encode₀[input]!3 - no lower or upper bound + encode₀[input]!4 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query1.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query1.txt.golden index 1fcdf8749..fa04db95c 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query1.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query1.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 -x0 +y2 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query10.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query10.txt.golden index e292e3b73..8aa75c1f5 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query10.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query10.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 +x4 -y6 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query2.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query2.txt.golden index 1fee8990d..7347c511a 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query2.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query2.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 +x0 -y2 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query3.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query3.txt.golden index f690c317a..b312286b4 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query3.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query3.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 -x1 +y3 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query4.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query4.txt.golden index d7bd14a6b..4c4756265 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query4.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query4.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 +x1 -y3 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query5.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query5.txt.golden index 272207370..552285992 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query5.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query5.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 -x2 +y4 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query6.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query6.txt.golden index e129225f8..25a8a04eb 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query6.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query6.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 +x2 -y4 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query7.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query7.txt.golden index 14ed4202b..cc4ebedb6 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query7.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query7.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 -x3 +y5 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query8.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query8.txt.golden index 8f6982eaa..018802f2f 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query8.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query8.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 +x3 -y5 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query9.txt.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query9.txt.golden index e1a13ecbb..ccca810a8 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query9.txt.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity-query9.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x5 -y0 = 0.0 +x6 -y1 = 0.0 -x4 +y6 <= -0.1 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity.vcl-plan.golden b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity.vcl-plan.golden index 351d6a074..3a15e78fd 100644 --- a/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity.vcl-plan.golden +++ b/vehicle/tests/golden/compile/autoencoderError/Marabou.queries/identity.vcl-plan.golden @@ -6,95 +6,352 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + } + ], + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -116,220 +373,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 + ] } } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 2 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -351,220 +704,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 + ] } } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 3 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -586,220 +1035,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 + ] } } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 4 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -821,220 +1366,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 + ] } } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 5 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -1056,220 +1697,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 + ] } } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 6 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -1291,455 +2028,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 - } - ] - ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "identity", - "propertyIndices": [] - }, - 7 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 5 - ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ + "tensorDims": [ 5 - ], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - }, + ] + }, + "coefficients": [ + [ { - "numerator": 0, - "denominator": 1 + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } }, { - "numerator": 0, + "numerator": -1, "denominator": 1 - }, + } + ], + [ { - "numerator": 0, - "denominator": 1 + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } }, { - "numerator": 0, + "numerator": 1, "denominator": 1 } - ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 - } - ] - ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + ] + } + } + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 8 + 7 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -1761,220 +2359,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 + ] } } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 9 + 8 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -1996,220 +2690,316 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 + ] } } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" - }, - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "identity", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 10 + 9 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ 5 ], - "unreducedUserVarName": "x" + "baseType": [] } }, - { - "solutionEquality": { + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { "dimensions": [ 5 ], - "constantValue": [ + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -2231,131 +3021,301 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 5 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 5 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "encode", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "encode", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "decode", - "inputOrOutput": "Input", - "application": 0 + ] } } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 5 - ], - "networkName": "decode", - "inputOrOutput": "Output", - "application": 0 - } + ] + } + ], + "queryAddress": [ + { + "propertyName": "identity", + "propertyIndices": [], + "propertyID": 0 + }, + 10 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "encode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "encode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 5, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "decode", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 2, + "networkTensorVarDimensions": [ + 5 + ], + "networkName": "decode", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] + "networkEntries": [ + { + "metaNetworkEntryName": "encode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + } }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "decode", - "metaNetworkEntryFilePath": "fake.onnx" + "networkFilepath": "fake.onnx" + } }, { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] + "metaNetworkEntryName": "decode", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 5 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } }, - "inputTensor": { - "dimensions": [ - 5 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "encode", - "metaNetworkEntryFilePath": "fake.onnx" + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/bounded/Marabou.err.golden b/vehicle/tests/golden/compile/bounded/Marabou.err.golden index e7893605f..25ddcffba 100644 --- a/vehicle/tests/golden/compile/bounded/Marabou.err.golden +++ b/vehicle/tests/golden/compile/bounded/Marabou.err.golden @@ -1,5 +1,5 @@  -Warning: While compiling property 'bounded', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'bounded', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). diff --git a/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query1.txt.golden b/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query1.txt.golden index b1420ae86..1281eefe5 100644 --- a/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query1.txt.golden +++ b/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query1.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev -x0 >= 0.0 +// - Vehicle version: 0.11.1+dev x0 <= 1.0 +x0 >= 0.0 y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query2.txt.golden b/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query2.txt.golden index 7cab60180..193b59494 100644 --- a/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query2.txt.golden +++ b/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded-query2.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev -x0 >= 0.0 +// - Vehicle version: 0.11.1+dev x0 <= 1.0 +x0 >= 0.0 y0 >= 1.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded.vcl-plan.golden b/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded.vcl-plan.golden index 05d280b12..0029e6207 100644 --- a/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded.vcl-plan.golden +++ b/vehicle/tests/golden/compile/bounded/Marabou.queries/bounded.vcl-plan.golden @@ -6,276 +6,260 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "bounded", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "bounded", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, + "metaNetwork": { + "variables": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "bounded", + "propertyIndices": [], + "propertyID": 0 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Agda.agda.golden b/vehicle/tests/golden/compile/dogsHierarchy/Agda.agda.golden index 66b885c8d..0ca672282 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Agda.agda.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query1.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query1.txt.golden index 679c43347..3f799ca37 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query1.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query1.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query10.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query10.txt.golden index 76166402c..0086fc77e 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query10.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query10.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query11.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query11.txt.golden index dcc3f67f2..fc53217a3 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query11.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query11.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query12.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query12.txt.golden index 328286781..99361677f 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query12.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query12.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query13.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query13.txt.golden index 91837194b..2972a853f 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query13.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query13.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query14.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query14.txt.golden index 8eeefda9e..92614ef8f 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query14.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query14.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query15.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query15.txt.golden index d7913fd9a..097a0b8e6 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query15.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query15.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query16.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query16.txt.golden index 913f0df3e..1206d3aa5 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query16.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query16.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query17.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query17.txt.golden index f4fbc2b13..4bc497e25 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query17.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query17.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query18.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query18.txt.golden index 798b034b7..06e44b77b 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query18.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query18.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query19.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query19.txt.golden index cb09040e6..e745a3506 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query19.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query19.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query2.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query2.txt.golden index 9af85c7bd..e4532ba06 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query2.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query2.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query20.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query20.txt.golden index 7f948a8ee..37a297007 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query20.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query20.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query21.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query21.txt.golden index daa1c6ed6..7841a85d4 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query21.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query21.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query22.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query22.txt.golden index 76d128d18..04d15425f 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query22.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query22.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query23.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query23.txt.golden index cce3008cb..813f41331 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query23.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query23.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query24.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query24.txt.golden index 3d26ac6ee..35a5b776c 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query24.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query24.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query3.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query3.txt.golden index b30aa357f..3c412afe8 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query3.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query3.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query4.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query4.txt.golden index 44174a7ad..37846bd3d 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query4.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query4.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query5.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query5.txt.golden index cddd84174..54090cafc 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query5.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query5.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query6.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query6.txt.golden index 60b3ed5d3..94f537273 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query6.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query6.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query7.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query7.txt.golden index 9e4ed2c5e..32744214b 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query7.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query7.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query8.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query8.txt.golden index 9f753a431..4a60167f3 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query8.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query8.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query9.txt.golden b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query9.txt.golden index d4616339b..d7b9fd3b5 100644 --- a/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query9.txt.golden +++ b/vehicle/tests/golden/compile/dogsHierarchy/Marabou.queries/doesNotConfuseBigAndSmall-query9.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 x0 <= 1.0 x1 >= 0.0 diff --git a/vehicle/tests/golden/compile/increasing/Agda.agda.golden b/vehicle/tests/golden/compile/increasing/Agda.agda.golden index 075edf734..e39ef09cf 100644 --- a/vehicle/tests/golden/compile/increasing/Agda.agda.golden +++ b/vehicle/tests/golden/compile/increasing/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/increasing/Marabou.err.golden b/vehicle/tests/golden/compile/increasing/Marabou.err.golden index 1289ff572..a59cbc2f6 100644 --- a/vehicle/tests/golden/compile/increasing/Marabou.err.golden +++ b/vehicle/tests/golden/compile/increasing/Marabou.err.golden @@ -1,13 +1,12 @@  -Warning: While compiling property 'increasing', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - - -Warning: While compiling property 'increasing', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'increasing', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'increasing', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing-query1.txt.golden b/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing-query1.txt.golden index 806aab73f..4a545dbeb 100644 --- a/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing-query1.txt.golden +++ b/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev -x0 +y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing.vcl-plan.golden b/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing.vcl-plan.golden index 026d2268d..3f518d035 100644 --- a/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing.vcl-plan.golden +++ b/vehicle/tests/golden/compile/increasing/Marabou.queries/increasing.vcl-plan.golden @@ -6,141 +6,133 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "increasing", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "increasing", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/issue551/Marabou.err.golden b/vehicle/tests/golden/compile/issue551/Marabou.err.golden index 9fdc9299d..99aee4fde 100644 --- a/vehicle/tests/golden/compile/issue551/Marabou.err.golden +++ b/vehicle/tests/golden/compile/issue551/Marabou.err.golden @@ -1,14 +1,13 @@  -Warning: While compiling property 'p', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - f₀[input]!1 - no constraints - - -Warning: While compiling property 'p', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'p', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'p', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound + f₀[input]!1 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/issue551/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/issue551/Marabou.queries/p-query1.txt.golden index 8ea9844c5..5cb34e50f 100644 --- a/vehicle/tests/golden/compile/issue551/Marabou.queries/p-query1.txt.golden +++ b/vehicle/tests/golden/compile/issue551/Marabou.queries/p-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 >= 0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue551/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/issue551/Marabou.queries/p.vcl-plan.golden index 2b9faa990..3b9f81274 100644 --- a/vehicle/tests/golden/compile/issue551/Marabou.queries/p.vcl-plan.golden +++ b/vehicle/tests/golden/compile/issue551/Marabou.queries/p.vcl-plan.golden @@ -6,65 +6,21 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "p", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 2 - ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ - 2 - ], - "constantValue": [ + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -74,83 +30,127 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 2 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/issue615/Marabou.err.golden b/vehicle/tests/golden/compile/issue615/Marabou.err.golden index 49c815f5a..b9cde945a 100644 --- a/vehicle/tests/golden/compile/issue615/Marabou.err.golden +++ b/vehicle/tests/golden/compile/issue615/Marabou.err.golden @@ -1,13 +1,12 @@  -Warning: While compiling property 'p', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - - -Warning: While compiling property 'p', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'p', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'p', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/issue615/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/issue615/Marabou.queries/p-query1.txt.golden index 8ea9844c5..5cb34e50f 100644 --- a/vehicle/tests/golden/compile/issue615/Marabou.queries/p-query1.txt.golden +++ b/vehicle/tests/golden/compile/issue615/Marabou.queries/p-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 >= 0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue615/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/issue615/Marabou.queries/p.vcl-plan.golden index 050d4e3c5..97733eddb 100644 --- a/vehicle/tests/golden/compile/issue615/Marabou.queries/p.vcl-plan.golden +++ b/vehicle/tests/golden/compile/issue615/Marabou.queries/p.vcl-plan.golden @@ -6,147 +6,133 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "p", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 1 + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ + "tensorDims": [ 1 - ], - "constantValue": [ + ] + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/issue649/Marabou.queries/robust-query1.txt.golden b/vehicle/tests/golden/compile/issue649/Marabou.queries/robust-query1.txt.golden index 8f86a5d53..3b85d993b 100644 --- a/vehicle/tests/golden/compile/issue649/Marabou.queries/robust-query1.txt.golden +++ b/vehicle/tests/golden/compile/issue649/Marabou.queries/robust-query1.txt.golden @@ -2,9 +2,9 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev -x0 >= 0.0 -x0 >= 0.95 -x0 <= 1.05 +// - Vehicle version: 0.11.1+dev ++y0 -y1 <= 0.0 x0 <= 1.0 -+y0 -y1 <= 0.0 \ No newline at end of file +x0 <= 1.05 +x0 >= 0.0 +x0 >= 0.95 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue649/Marabou.queries/robust.vcl-plan.golden b/vehicle/tests/golden/compile/issue649/Marabou.queries/robust.vcl-plan.golden index 149e1d87b..8363a7ab5 100644 --- a/vehicle/tests/golden/compile/issue649/Marabou.queries/robust.vcl-plan.golden +++ b/vehicle/tests/golden/compile/issue649/Marabou.queries/robust.vcl-plan.golden @@ -6,153 +6,154 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "robust", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1, - 1 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "perturbation", - "userVarDimensions": [ - 1, - 1 + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "perturbation", + "userTensorVarDimensions": [ + 1, + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": -1, + "denominator": 1 + } ], - "unreducedUserVarName": "perturbation" - } - }, - { - "solutionEquality": { - "dimensions": [ + "tensorDims": [ 1, 1 - ], - "constantValue": [ + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "perturbation", + "userTensorVarDimensions": [ + 1, + 1 + ] + } + }, { "numerator": 1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1, - 1 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1, + 1 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1, + 1 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1, - 1 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1, - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1, + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/issue669/Marabou.err.golden b/vehicle/tests/golden/compile/issue669/Marabou.err.golden index 04a5e0ec6..fad8e9cd6 100644 --- a/vehicle/tests/golden/compile/issue669/Marabou.err.golden +++ b/vehicle/tests/golden/compile/issue669/Marabou.err.golden @@ -1,3 +1,3 @@  -Warning: The property 'p' was found to evalute to 'True' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used. +Warning: The property 'p' was found to evaluate to 'True' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used.  diff --git a/vehicle/tests/golden/compile/issue699/spec.vcl b/vehicle/tests/golden/compile/issue699/spec.vcl index d80fe377b..aea3dccef 100644 --- a/vehicle/tests/golden/compile/issue699/spec.vcl +++ b/vehicle/tests/golden/compile/issue699/spec.vcl @@ -9,7 +9,7 @@ validImage x = forall i j . 0 <= x ! i ! j <= 1 classifier : Image -> Vector Rat 10 scaler : Image -> Rat -scaler x = classifier x ! 0 + classifier x ! 1 + classifier x ! 2 + classifier x ! 3 + classifier x ! 4 + classifier x ! 5 + classifier x ! 6 + classifier x ! 7 + classifier x ! 8 + classifier x ! 9 +scaler x = classifier x ! 0 + classifier x ! 1 + classifier x ! 2 + classifier x ! 3 + classifier x ! 4 + classifier x ! 5 + classifier x ! 6 + classifier x ! 7 + classifier x ! 8 + classifier x ! 9 scaleCOutput : Image -> Label -> Rat scaleCOutput x i = ((classifier x) ! i) / (scaler x) diff --git a/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalcious.vcl-plan.golden b/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalcious.vcl-plan.golden deleted file mode 100644 index ed03d59a1..000000000 --- a/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalcious.vcl-plan.golden +++ /dev/null @@ -1,108 +0,0 @@ -{ - "queryMetaData": { - "tag": "NonTrivial", - "contents": { - "tag": "Query", - "contents": { - "queries": { - "unDisjunctAll": [ - [ - [ - { - "propertyName": "isMalcious", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ] - ] - }, - "negated": false - } - } - } -} \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalcious-query1.txt.golden b/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalicious-query1.txt.golden similarity index 83% rename from vehicle/tests/golden/compile/issue712/Marabou.queries/isMalcious-query1.txt.golden rename to vehicle/tests/golden/compile/issue712/Marabou.queries/isMalicious-query1.txt.golden index 6b9580eff..55042709e 100644 --- a/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalcious-query1.txt.golden +++ b/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalicious-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 y0 >= 0.5 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalicious.vcl-plan.golden b/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalicious.vcl-plan.golden new file mode 100644 index 000000000..19f1549cf --- /dev/null +++ b/vehicle/tests/golden/compile/issue712/Marabou.queries/isMalicious.vcl-plan.golden @@ -0,0 +1,80 @@ +{ + "queryMetaData": { + "tag": "NonTrivial", + "contents": { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [], + "queryAddress": [ + { + "propertyName": "isMalicious", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": false + } + } + } +} \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue712/MarabouQueries.err.golden b/vehicle/tests/golden/compile/issue712/MarabouQueries.err.golden index 6474cadb6..444f99fae 100644 --- a/vehicle/tests/golden/compile/issue712/MarabouQueries.err.golden +++ b/vehicle/tests/golden/compile/issue712/MarabouQueries.err.golden @@ -1,5 +1,5 @@  -Warning: While compiling property 'isMalcious', in at least one of the generated SAT problems all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of degenerate problems. +Warning: In property 'isMalicious', in query 1 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details.  diff --git a/vehicle/tests/golden/compile/issue712/spec.vcl b/vehicle/tests/golden/compile/issue712/spec.vcl index deb996eb6..08824d17f 100644 --- a/vehicle/tests/golden/compile/issue712/spec.vcl +++ b/vehicle/tests/golden/compile/issue712/spec.vcl @@ -5,5 +5,5 @@ decide : Vector Rat 1 -> Index 2 decide x = if f x ! 0 < 0.5 then 0 else 1 @property -isMalcious : Bool -isMalcious = decide [0] == 1 +isMalicious : Bool +isMalicious = decide [0] == 1 diff --git a/vehicle/tests/golden/compile/issue712/test.json b/vehicle/tests/golden/compile/issue712/test.json index 8f0f77e4f..d62aa13af 100644 --- a/vehicle/tests/golden/compile/issue712/test.json +++ b/vehicle/tests/golden/compile/issue712/test.json @@ -6,7 +6,7 @@ "fake.onnx" ], "produces": [ - "Marabou.queries/isMalcious-query1.txt", - "Marabou.queries/isMalcious.vcl-plan" + "Marabou.queries/isMalicious-query1.txt", + "Marabou.queries/isMalicious.vcl-plan" ] } diff --git a/vehicle/tests/golden/compile/issue750/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/issue750/Marabou.queries/p-query1.txt.golden new file mode 100644 index 000000000..5f8e5234d --- /dev/null +++ b/vehicle/tests/golden/compile/issue750/Marabou.queries/p-query1.txt.golden @@ -0,0 +1,11 @@ +// WARNING: This file was generated automatically by Vehicle +// and should not be modified manually! +// Metadata: +// - Marabou query format version: unknown +// - Vehicle version: 0.11.1+dev ++x0 -x1 = 0.0 ++y0 -y1 <= 0.0 +x0 <= 1.0 +x0 >= 0.0 +x1 <= 1.0 +x1 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue750/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/issue750/Marabou.queries/p.vcl-plan.golden new file mode 100644 index 000000000..d3e5d71bc --- /dev/null +++ b/vehicle/tests/golden/compile/issue750/Marabou.queries/p.vcl-plan.golden @@ -0,0 +1,251 @@ +{ + "queryMetaData": { + "tag": "NonTrivial", + "contents": { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } + ], + "tensorDims": [ + 1 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + }, + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "y", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } + ], + "tensorDims": [ + 1 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "y", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 1 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": false + } + } + } +} \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue750/fake.onnx b/vehicle/tests/golden/compile/issue750/fake.onnx new file mode 100644 index 000000000..94f52176a --- /dev/null +++ b/vehicle/tests/golden/compile/issue750/fake.onnx @@ -0,0 +1 @@ +FAKE ONNX NETWORK diff --git a/vehicle/tests/golden/compile/issue750/spec.vcl b/vehicle/tests/golden/compile/issue750/spec.vcl new file mode 100644 index 000000000..299af935b --- /dev/null +++ b/vehicle/tests/golden/compile/issue750/spec.vcl @@ -0,0 +1,6 @@ +@network +f : Tensor Rat [1] -> Tensor Rat [1] + +@property +p : Bool +p = exists x y . f x ! 0 <= f y ! 0 and x == y and 0 <= x ! 0 <= 1 and 0 <= y ! 0 <= 1 diff --git a/vehicle/tests/golden/compile/issue750/test.json b/vehicle/tests/golden/compile/issue750/test.json new file mode 100644 index 000000000..e99e5903c --- /dev/null +++ b/vehicle/tests/golden/compile/issue750/test.json @@ -0,0 +1,11 @@ +[ + { + "name": "Marabou", + "run": "vehicle compile -s spec.vcl -t MarabouQueries -o Marabou.queries/ --network f:fake.onnx", + "needs": ["spec.vcl", "fake.onnx"], + "produces": ["Marabou.queries/*.txt", "Marabou.queries/p.vcl-plan"], + "ignore": { + "lines": ".*\"fileHash\".*" + } + } +] diff --git a/vehicle/tests/golden/compile/issue765/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/issue765/Marabou.queries/p-query1.txt.golden new file mode 100644 index 000000000..aa22a6c95 --- /dev/null +++ b/vehicle/tests/golden/compile/issue765/Marabou.queries/p-query1.txt.golden @@ -0,0 +1,8 @@ +// WARNING: This file was generated automatically by Vehicle +// and should not be modified manually! +// Metadata: +// - Marabou query format version: unknown +// - Vehicle version: 0.11.1+dev +x0 = 0.0 +x1 = 0.0 +y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue765/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/issue765/Marabou.queries/p.vcl-plan.golden new file mode 100644 index 000000000..792e8a6cd --- /dev/null +++ b/vehicle/tests/golden/compile/issue765/Marabou.queries/p.vcl-plan.golden @@ -0,0 +1,94 @@ +{ + "queryMetaData": { + "tag": "NonTrivial", + "contents": { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [], + "queryAddress": [ + { + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": false + } + } + } +} \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue765/MarabouQueries.err.golden b/vehicle/tests/golden/compile/issue765/MarabouQueries.err.golden new file mode 100644 index 000000000..e32e8df81 --- /dev/null +++ b/vehicle/tests/golden/compile/issue765/MarabouQueries.err.golden @@ -0,0 +1,5 @@ + +Warning: In property 'p', in query 1 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. + +See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details. + diff --git a/vehicle/tests/golden/compile/issue765/fake.onnx b/vehicle/tests/golden/compile/issue765/fake.onnx new file mode 100644 index 000000000..94f52176a --- /dev/null +++ b/vehicle/tests/golden/compile/issue765/fake.onnx @@ -0,0 +1 @@ +FAKE ONNX NETWORK diff --git a/vehicle/tests/golden/compile/issue765/spec.vcl b/vehicle/tests/golden/compile/issue765/spec.vcl new file mode 100644 index 000000000..c0694c3a2 --- /dev/null +++ b/vehicle/tests/golden/compile/issue765/spec.vcl @@ -0,0 +1,9 @@ +@parameter +n : Nat + +@network +f : Vector Rat n -> Vector Rat 1 + +@property +p : Bool +p = f (foreach i . 0) ! 0 >= 0 diff --git a/vehicle/tests/golden/compile/issue765/test.json b/vehicle/tests/golden/compile/issue765/test.json new file mode 100644 index 000000000..01326ceb1 --- /dev/null +++ b/vehicle/tests/golden/compile/issue765/test.json @@ -0,0 +1,9 @@ +{ + "name": "MarabouQueries", + "run": "vehicle compile -t MarabouQueries -s spec.vcl -n f:fake.onnx -p n:2 -o Marabou.queries/", + "needs": [ + "spec.vcl", + "fake.onnx" + ], + "produces": ["Marabou.queries/*.txt", "Marabou.queries/p.vcl-plan"] +} diff --git a/vehicle/tests/golden/compile/issue86/Marabou.err.golden b/vehicle/tests/golden/compile/issue86/Marabou.err.golden new file mode 100644 index 000000000..e09eda4a8 --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/Marabou.err.golden @@ -0,0 +1,17 @@ + +Warning: In property 'p1', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound + + +Warning: In property 'p3', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + +In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). + +See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'p3', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In queries 1 and 2: + f₁[input]!0 - no lower or upper bound + diff --git a/vehicle/tests/golden/compile/issue86/Marabou.queries/p1-query1.txt.golden b/vehicle/tests/golden/compile/issue86/Marabou.queries/p1-query1.txt.golden new file mode 100644 index 000000000..96e77a763 --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/Marabou.queries/p1-query1.txt.golden @@ -0,0 +1,6 @@ +// WARNING: This file was generated automatically by Vehicle +// and should not be modified manually! +// Metadata: +// - Marabou query format version: unknown +// - Vehicle version: 0.11.1+dev +y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue86/Marabou.queries/p1.vcl-plan.golden b/vehicle/tests/golden/compile/issue86/Marabou.queries/p1.vcl-plan.golden new file mode 100644 index 000000000..d2b2c4cf2 --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/Marabou.queries/p1.vcl-plan.golden @@ -0,0 +1,142 @@ +{ + "queryMetaData": { + "tag": "NonTrivial", + "contents": { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } + ], + "tensorDims": [ + 1 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p1", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": true + } + } + } +} \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue86/Marabou.queries/p3-query1.txt.golden b/vehicle/tests/golden/compile/issue86/Marabou.queries/p3-query1.txt.golden new file mode 100644 index 000000000..4283a5ec1 --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/Marabou.queries/p3-query1.txt.golden @@ -0,0 +1,8 @@ +// WARNING: This file was generated automatically by Vehicle +// and should not be modified manually! +// Metadata: +// - Marabou query format version: unknown +// - Vehicle version: 0.11.1+dev +x0 = 0.0 +y0 <= 0.0 +y1 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue86/Marabou.queries/p3-query2.txt.golden b/vehicle/tests/golden/compile/issue86/Marabou.queries/p3-query2.txt.golden new file mode 100644 index 000000000..7ed53b2cf --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/Marabou.queries/p3-query2.txt.golden @@ -0,0 +1,8 @@ +// WARNING: This file was generated automatically by Vehicle +// and should not be modified manually! +// Metadata: +// - Marabou query format version: unknown +// - Vehicle version: 0.11.1+dev +x0 = 0.0 +y1 <= 0.0 +y1 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue86/Marabou.queries/p3.vcl-plan.golden b/vehicle/tests/golden/compile/issue86/Marabou.queries/p3.vcl-plan.golden new file mode 100644 index 000000000..1114de609 --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/Marabou.queries/p3.vcl-plan.golden @@ -0,0 +1,365 @@ +{ + "queryMetaData": { + "tag": "NonTrivial", + "contents": { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 + } + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p3", + "propertyIndices": [], + "propertyID": 1 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 1 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 + } + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p3", + "propertyIndices": [], + "propertyID": 1 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 1 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + }, + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": true + } + } + } +} \ No newline at end of file diff --git a/vehicle/tests/golden/compile/issue86/fake.onnx b/vehicle/tests/golden/compile/issue86/fake.onnx new file mode 100644 index 000000000..94f52176a --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/fake.onnx @@ -0,0 +1 @@ +FAKE ONNX NETWORK diff --git a/vehicle/tests/golden/compile/issue86/spec.vcl b/vehicle/tests/golden/compile/issue86/spec.vcl new file mode 100644 index 000000000..73b2deb70 --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/spec.vcl @@ -0,0 +1,14 @@ +@network +f : Tensor Rat [1] -> Tensor Rat [1] + +@property +p1 : Bool +p1 = forall x . forall y in f x . y > 0 +{- +@property +p2 : Bool +p2 = fold (\x r -> x > 0 and r) True (f [0]) +-} +@property +p3 : Bool +p3 = forall x . fold (\a b -> a > 0 and b) True (f [if f [x] ! 0 > 0 then 0 else x]) diff --git a/vehicle/tests/golden/compile/issue86/test.json b/vehicle/tests/golden/compile/issue86/test.json new file mode 100644 index 000000000..9cdafb2c9 --- /dev/null +++ b/vehicle/tests/golden/compile/issue86/test.json @@ -0,0 +1,16 @@ +{ + "name": "Marabou", + "run": "vehicle compile -s spec.vcl -t MarabouQueries -o Marabou.queries/ --network f:fake.onnx", + "needs": [ + "spec.vcl", + "fake.onnx" + ], + "produces": [ + "Marabou.queries/p1.vcl-plan", + "Marabou.queries/p3.vcl-plan", + "Marabou.queries/*.txt" + ], + "ignore": { + "lines": ".*\"fileHash\".*" + } +} diff --git a/vehicle/tests/golden/compile/mnist-robustness/Agda.agda.golden b/vehicle/tests/golden/compile/mnist-robustness/Agda.agda.golden index 63deb1f5d..b78db6a6e 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Agda.agda.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query1.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query1.txt.golden index 32a295ab3..872298671 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query1.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query1.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y0 +y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query2.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query2.txt.golden index 15357e8e1..305d2c2c4 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query2.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query2.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y1 +y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y1 +y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query3.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query3.txt.golden index ca6a77f68..4675f36bf 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query3.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query3.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y2 +y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y2 +y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query4.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query4.txt.golden index 422ed0eb1..5b2b306f0 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query4.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query4.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y3 +y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y3 +y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query5.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query5.txt.golden index fdec4995c..9293355bc 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query5.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query5.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y4 +y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y4 +y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query6.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query6.txt.golden index a9866ea89..30eac07c4 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query6.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query6.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y5 +y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y5 +y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query7.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query7.txt.golden index fd702d388..9a3df1b07 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query7.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query7.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y6 +y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y6 +y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query8.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query8.txt.golden index a57d630a0..fb400d060 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query8.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query8.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y7 -y8 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y7 -y8 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query9.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query9.txt.golden index f1dd3c475..c96dcef8b 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query9.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0-query9.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y7 -y9 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 -x42 >= -0.1 -x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 -x43 >= -0.1 -x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 -x44 >= -0.1 -x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 -x45 >= -0.1 -x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x42 <= 0.17058823529411765 +x42 <= 1.0705882352941176 +x42 >= -0.029411764705882353 +x42 >= 0.07058823529411765 +x43 <= 0.9117647058823529 +x43 <= 1.811764705882353 +x43 >= 0.711764705882353 +x43 >= 0.8117647058823529 +x44 <= 1.0960784313725491 +x44 <= 1.996078431372549 +x44 >= 0.8960784313725491 +x44 >= 0.996078431372549 +x45 <= 0.5745098039215686 +x45 <= 1.4745098039215687 +x45 >= 0.37450980392156863 +x45 >= 0.4745098039215686 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 -x69 >= -0.1 -x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 -x70 >= -0.1 -x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 -x71 >= -0.1 -x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 -x72 >= -0.1 -x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 -x73 >= -0.1 -x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x69 <= 0.2568627450980392 +x69 <= 1.156862745098039 +x69 >= 0.056862745098039215 +x69 >= 0.1568627450980392 +x70 <= 0.9588235294117646 +x70 <= 1.8588235294117648 +x70 >= 0.7588235294117647 +x70 >= 0.8588235294117647 +x71 <= 1.0960784313725491 +x71 <= 1.996078431372549 +x71 >= 0.8960784313725491 +x71 >= 0.996078431372549 +x72 <= 1.0960784313725491 +x72 <= 1.996078431372549 +x72 >= 0.8960784313725491 +x72 >= 0.996078431372549 +x73 <= 0.5745098039215686 +x73 <= 1.4745098039215687 +x73 >= 0.37450980392156863 +x73 >= 0.4745098039215686 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 +x94 <= 0.1 +x94 <= 1.0 x94 >= -0.1 x94 >= 0.0 -x94 <= 1.0 -x94 <= 0.1 +x95 <= 0.1 +x95 <= 1.0 x95 >= -0.1 x95 >= 0.0 -x95 <= 1.0 -x95 <= 0.1 +x96 <= 0.1 +x96 <= 1.0 x96 >= -0.1 x96 >= 0.0 -x96 <= 1.0 -x96 <= 0.1 -x97 >= -0.1 -x97 >= 0.0 -x97 <= 1.0 -x97 <= 0.1 -x98 >= -0.1 -x98 >= 0.0 -x98 <= 1.0 -x98 <= 0.1 -x99 >= -0.1 -x99 >= 0.0 -x99 <= 1.0 -x99 <= 0.1 -x100 >= -0.1 -x100 >= 0.0 -x100 <= 1.0 -x100 <= 0.1 -x101 >= -0.1 -x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x97 <= 0.30392156862745096 +x97 <= 1.203921568627451 +x97 >= 0.10392156862745097 +x97 >= 0.20392156862745098 +x98 <= 1.0960784313725491 +x98 <= 1.996078431372549 +x98 >= 0.8960784313725491 +x98 >= 0.996078431372549 +x99 <= 1.0960784313725491 +x99 <= 1.996078431372549 +x99 >= 0.8960784313725491 +x99 >= 0.996078431372549 +x100 <= 1.0490196078431373 +x100 <= 1.9490196078431372 +x100 >= 0.8490196078431372 +x100 >= 0.9490196078431372 +x101 <= 0.3392156862745098 +x101 <= 1.2392156862745098 +x101 >= 0.1392156862745098 +x101 >= 0.23921568627450981 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 +x121 <= 0.1 +x121 <= 1.0 x121 >= -0.1 x121 >= 0.0 -x121 <= 1.0 -x121 <= 0.1 +x122 <= 0.1 +x122 <= 1.0 x122 >= -0.1 x122 >= 0.0 -x122 <= 1.0 -x122 <= 0.1 +x123 <= 0.1 +x123 <= 1.0 x123 >= -0.1 x123 >= 0.0 -x123 <= 1.0 -x123 <= 0.1 +x124 <= 0.1 +x124 <= 1.0 x124 >= -0.1 x124 >= 0.0 -x124 <= 1.0 -x124 <= 0.1 -x125 >= -0.1 -x125 >= 0.0 -x125 <= 1.0 -x125 <= 0.1 -x126 >= -0.1 -x126 >= 0.0 -x126 <= 1.0 -x126 <= 0.1 -x127 >= -0.1 -x127 >= 0.0 -x127 <= 1.0 -x127 <= 0.1 -x128 >= -0.1 -x128 >= 0.0 -x128 <= 1.0 -x128 <= 0.1 +x125 <= 0.30392156862745096 +x125 <= 1.203921568627451 +x125 >= 0.10392156862745097 +x125 >= 0.20392156862745098 +x126 <= 1.0960784313725491 +x126 <= 1.996078431372549 +x126 >= 0.8960784313725491 +x126 >= 0.996078431372549 +x127 <= 1.0960784313725491 +x127 <= 1.996078431372549 +x127 >= 0.8960784313725491 +x127 >= 0.996078431372549 +x128 <= 0.6215686274509804 +x128 <= 1.5215686274509803 +x128 >= 0.42156862745098045 +x128 >= 0.5215686274509804 +x129 <= 0.1 +x129 <= 1.0 x129 >= -0.1 x129 >= 0.0 -x129 <= 1.0 -x129 <= 0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 +x147 <= 0.1 +x147 <= 1.0 x147 >= -0.1 x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 +x148 <= 0.1 +x148 <= 1.0 x148 >= -0.1 x148 >= 0.0 -x148 <= 1.0 -x148 <= 0.1 +x149 <= 0.1 +x149 <= 1.0 x149 >= -0.1 x149 >= 0.0 -x149 <= 1.0 -x149 <= 0.1 +x150 <= 0.1 +x150 <= 1.0 x150 >= -0.1 x150 >= 0.0 -x150 <= 1.0 -x150 <= 0.1 +x151 <= 0.1 +x151 <= 1.0 x151 >= -0.1 x151 >= 0.0 -x151 <= 1.0 -x151 <= 0.1 -x152 >= -0.1 -x152 >= 0.0 -x152 <= 1.0 -x152 <= 0.1 -x153 >= -0.1 -x153 >= 0.0 -x153 <= 1.0 -x153 <= 0.1 -x154 >= -0.1 -x154 >= 0.0 -x154 <= 1.0 -x154 <= 0.1 -x155 >= -0.1 -x155 >= 0.0 -x155 <= 1.0 -x155 <= 0.1 -x156 >= -0.1 -x156 >= 0.0 -x156 <= 1.0 -x156 <= 0.1 +x152 <= 0.10392156862745099 +x152 <= 1.003921568627451 +x152 >= -0.09607843137254903 +x152 >= 0.00392156862745098 +x153 <= 0.5509803921568628 +x153 <= 1.4509803921568627 +x153 >= 0.3509803921568628 +x153 >= 0.45098039215686275 +x154 <= 1.0960784313725491 +x154 <= 1.996078431372549 +x154 >= 0.8960784313725491 +x154 >= 0.996078431372549 +x155 <= 0.9784313725490196 +x155 <= 1.8784313725490196 +x155 >= 0.7784313725490196 +x155 >= 0.8784313725490196 +x156 <= 0.22156862745098038 +x156 <= 1.1215686274509804 +x156 >= 0.021568627450980392 +x156 >= 0.12156862745098039 +x157 <= 0.1 +x157 <= 1.0 x157 >= -0.1 x157 >= 0.0 -x157 <= 1.0 -x157 <= 0.1 +x158 <= 0.1 +x158 <= 1.0 x158 >= -0.1 x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 +x169 <= 0.1 +x169 <= 1.0 x169 >= -0.1 x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 +x170 <= 0.1 +x170 <= 1.0 x170 >= -0.1 x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 +x171 <= 0.1 +x171 <= 1.0 x171 >= -0.1 x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 +x172 <= 0.1 +x172 <= 1.0 x172 >= -0.1 x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 +x173 <= 0.1 +x173 <= 1.0 x173 >= -0.1 x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 +x174 <= 0.1 +x174 <= 1.0 x174 >= -0.1 x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 +x175 <= 0.1 +x175 <= 1.0 x175 >= -0.1 x175 >= 0.0 -x175 <= 1.0 -x175 <= 0.1 +x176 <= 0.1 +x176 <= 1.0 x176 >= -0.1 x176 >= 0.0 -x176 <= 1.0 -x176 <= 0.1 +x177 <= 0.1 +x177 <= 1.0 x177 >= -0.1 x177 >= 0.0 -x177 <= 1.0 -x177 <= 0.1 +x178 <= 0.1 +x178 <= 1.0 x178 >= -0.1 x178 >= 0.0 -x178 <= 1.0 -x178 <= 0.1 +x179 <= 0.1 +x179 <= 1.0 x179 >= -0.1 x179 >= 0.0 -x179 <= 1.0 -x179 <= 0.1 -x180 >= -0.1 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.1 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.1 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.1 -x183 >= -0.1 -x183 >= 0.0 -x183 <= 1.0 -x183 <= 0.1 +x180 <= 0.40196078431372545 +x180 <= 1.3019607843137255 +x180 >= 0.20196078431372547 +x180 >= 0.30196078431372547 +x181 <= 1.0960784313725491 +x181 <= 1.996078431372549 +x181 >= 0.8960784313725491 +x181 >= 0.996078431372549 +x182 <= 1.0960784313725491 +x182 <= 1.996078431372549 +x182 >= 0.8960784313725491 +x182 >= 0.996078431372549 +x183 <= 0.24901960784313726 +x183 <= 1.1490196078431372 +x183 >= 0.049019607843137254 +x183 >= 0.14901960784313725 +x184 <= 0.1 +x184 <= 1.0 x184 >= -0.1 x184 >= 0.0 -x184 <= 1.0 -x184 <= 0.1 +x185 <= 0.1 +x185 <= 1.0 x185 >= -0.1 x185 >= 0.0 -x185 <= 1.0 -x185 <= 0.1 +x186 <= 0.1 +x186 <= 1.0 x186 >= -0.1 x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 +x187 <= 0.1 +x187 <= 1.0 x187 >= -0.1 x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 +x197 <= 0.1 +x197 <= 1.0 x197 >= -0.1 x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 +x198 <= 0.1 +x198 <= 1.0 x198 >= -0.1 x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 +x199 <= 0.1 +x199 <= 1.0 x199 >= -0.1 x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 +x200 <= 0.1 +x200 <= 1.0 x200 >= -0.1 x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 +x201 <= 0.1 +x201 <= 1.0 x201 >= -0.1 x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= 0.0 -x202 >= 0.22941176470588234 -x202 <= 1.0 -x202 <= 0.4294117647058823 -x203 >= 0.0 -x203 >= 0.6254901960784314 -x203 <= 1.0 -x203 <= 0.8254901960784313 -x204 >= 0.0 -x204 >= 0.5235294117647059 -x204 <= 1.0 -x204 <= 0.7235294117647059 -x205 >= 0.0 -x205 >= 0.49215686274509807 -x205 <= 1.0 -x205 <= 0.692156862745098 -x206 >= 0.0 -x206 >= 0.13529411764705881 -x206 <= 1.0 -x206 <= 0.3352941176470588 -x207 >= 0.0 -x207 >= 0.041176470588235294 -x207 <= 1.0 -x207 <= 0.2411764705882353 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= -0.1 -x210 >= 0.0 -x210 <= 1.0 -x210 <= 0.1 -x211 >= -0.1 -x211 >= 0.0 -x211 <= 1.0 -x211 <= 0.1 +x202 <= 0.1 +x202 <= 0.6705882352941177 +x202 >= -0.32941176470588235 +x202 >= -0.1 +x203 <= 0.1 +x203 <= 0.27450980392156865 +x203 >= -0.7254901960784313 +x203 >= -0.1 +x204 <= 0.1 +x204 <= 0.3764705882352941 +x204 >= -0.6235294117647059 +x204 >= -0.1 +x205 <= 0.1 +x205 <= 0.40784313725490196 +x205 >= -0.592156862745098 +x205 >= -0.1 +x206 <= 0.1 +x206 <= 0.7647058823529411 +x206 >= -0.23529411764705882 +x206 >= -0.1 +x207 <= 0.23725490196078433 +x207 <= 0.996078431372549 +x207 >= -0.0039215686274509665 +x207 >= 0.03725490196078433 +x208 <= 0.9588235294117646 +x208 <= 1.8588235294117648 +x208 >= 0.7588235294117647 +x208 >= 0.8588235294117647 +x209 <= 1.0960784313725491 +x209 <= 1.996078431372549 +x209 >= 0.8960784313725491 +x209 >= 0.996078431372549 +x210 <= 0.896078431372549 +x210 <= 1.7960784313725489 +x210 >= 0.696078431372549 +x210 >= 0.796078431372549 +x211 <= 0.11176470588235295 +x211 <= 1.011764705882353 +x211 >= -0.08823529411764706 +x211 >= 0.011764705882352941 +x212 <= 0.1 +x212 <= 1.0 x212 >= -0.1 x212 >= 0.0 -x212 <= 1.0 -x212 <= 0.1 +x213 <= 0.1 +x213 <= 1.0 x213 >= -0.1 x213 >= 0.0 -x213 <= 1.0 -x213 <= 0.1 +x214 <= 0.1 +x214 <= 1.0 x214 >= -0.1 x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 +x215 <= 0.1 +x215 <= 1.0 x215 >= -0.1 x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 +x225 <= 0.1 +x225 <= 1.0 x225 >= -0.1 x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 +x226 <= 0.1 +x226 <= 1.0 x226 >= -0.1 x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 +x227 <= 0.1 +x227 <= 1.0 x227 >= -0.1 x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 +x228 <= 0.1 +x228 <= 1.0 x228 >= -0.1 x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 +x229 <= 0.1 +x229 <= 1.0 x229 >= -0.1 x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= 0.0 -x230 >= 0.7705882352941177 -x230 <= 1.0 -x230 <= 0.9705882352941176 -x231 >= 0.0 -x231 >= 0.8960784313725491 -x231 <= 1.0960784313725491 -x231 <= 1.0 -x232 >= 0.0 -x232 >= 0.8960784313725491 -x232 <= 1.0960784313725491 -x232 <= 1.0 -x233 >= 0.0 -x233 >= 0.8960784313725491 -x233 <= 1.0960784313725491 -x233 <= 1.0 -x234 >= 0.0 -x234 >= 0.8960784313725491 -x234 <= 1.0960784313725491 -x234 <= 1.0 -x235 >= 0.0 -x235 >= 0.8450980392156863 -x235 <= 1.0450980392156863 -x235 <= 1.0 -x236 >= 0.0 -x236 >= 0.6764705882352942 -x236 <= 1.0 -x236 <= 0.8764705882352941 -x237 >= 0.0 -x237 >= 0.6764705882352942 -x237 <= 1.0 -x237 <= 0.8764705882352941 -x238 >= 0.0 -x238 >= 0.6764705882352942 -x238 <= 1.0 -x238 <= 0.8764705882352941 -x239 >= 0.0 -x239 >= 0.6764705882352942 -x239 <= 1.0 -x239 <= 0.8764705882352941 -x240 >= 0.0 -x240 >= 0.6764705882352942 -x240 <= 1.0 -x240 <= 0.8764705882352941 -x241 >= 0.0 -x241 >= 0.6764705882352942 -x241 <= 1.0 -x241 <= 0.8764705882352941 -x242 >= 0.0 -x242 >= 0.6764705882352942 -x242 <= 1.0 -x242 <= 0.8764705882352941 -x243 >= 0.0 -x243 >= 0.6764705882352942 -x243 <= 1.0 -x243 <= 0.8764705882352941 -x244 >= 0.0 -x244 >= 0.5666666666666667 -x244 <= 1.0 -x244 <= 0.7666666666666666 -x245 >= 0.0 -x245 >= 0.10392156862745097 -x245 <= 1.0 -x245 <= 0.30392156862745096 +x230 <= 0.1 +x230 <= 0.12941176470588234 +x230 >= -0.8705882352941177 +x230 >= -0.1 +x231 <= 0.0039215686274509665 +x231 <= 0.1 +x231 >= -0.996078431372549 +x231 >= -0.1 +x232 <= 0.0039215686274509665 +x232 <= 0.1 +x232 >= -0.996078431372549 +x232 >= -0.1 +x233 <= 0.0039215686274509665 +x233 <= 0.1 +x233 >= -0.996078431372549 +x233 >= -0.1 +x234 <= 0.0039215686274509665 +x234 <= 0.1 +x234 >= -0.996078431372549 +x234 >= -0.1 +x235 <= 0.7058823529411765 +x235 <= 0.7509803921568627 +x235 >= -0.2941176470588235 +x235 >= 0.5509803921568628 +x236 <= 1.0960784313725491 +x236 <= 1.219607843137255 +x236 >= 0.2196078431372549 +x236 >= 0.8960784313725491 +x237 <= 0.9666666666666667 +x237 <= 1.0901960784313727 +x237 >= 0.09019607843137256 +x237 >= 0.7666666666666667 +x238 <= 0.17450980392156862 +x238 <= 0.2980392156862745 +x238 >= -0.7019607843137255 +x238 >= -0.025490196078431372 +x239 <= 0.1 +x239 <= 0.22352941176470587 +x239 >= -0.7764705882352941 +x239 >= -0.1 +x240 <= 0.1 +x240 <= 0.22352941176470587 +x240 >= -0.7764705882352941 +x240 >= -0.1 +x241 <= 0.1 +x241 <= 0.22352941176470587 +x241 >= -0.7764705882352941 +x241 >= -0.1 +x242 <= 0.1 +x242 <= 0.22352941176470587 +x242 >= -0.7764705882352941 +x242 >= -0.1 +x243 <= 0.1 +x243 <= 0.22352941176470587 +x243 >= -0.7764705882352941 +x243 >= -0.1 +x244 <= 0.1 +x244 <= 0.33333333333333337 +x244 >= -0.6666666666666666 +x244 >= -0.1 +x245 <= 0.1 +x245 <= 0.7960784313725491 +x245 >= -0.20392156862745098 +x245 >= -0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 -x258 >= 0.0 -x258 >= 0.1627450980392157 -x258 <= 1.0 -x258 <= 0.3627450980392157 -x259 >= 0.0 -x259 >= 0.3470588235294118 -x259 <= 1.0 -x259 <= 0.5470588235294118 -x260 >= 0.0 -x260 >= 0.18235294117647058 -x260 <= 1.0 -x260 <= 0.38235294117647056 -x261 >= 0.0 -x261 >= 0.3470588235294118 -x261 <= 1.0 -x261 <= 0.5470588235294118 -x262 >= 0.0 -x262 >= 0.5392156862745098 -x262 <= 1.0 -x262 <= 0.7392156862745097 -x263 >= 0.0 -x263 >= 0.7901960784313725 -x263 <= 1.0 -x263 <= 0.9901960784313725 -x264 >= 0.0 -x264 >= 0.8960784313725491 -x264 <= 1.0960784313725491 -x264 <= 1.0 -x265 >= 0.0 -x265 >= 0.7823529411764706 -x265 <= 1.0 -x265 <= 0.9823529411764705 -x266 >= 0.0 -x266 >= 0.8960784313725491 -x266 <= 1.0960784313725491 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8960784313725491 -x267 <= 1.0960784313725491 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.8960784313725491 -x268 <= 1.0960784313725491 -x268 <= 1.0 -x269 >= 0.0 -x269 >= 0.8803921568627451 -x269 <= 1.080392156862745 -x269 <= 1.0 -x270 >= 0.0 -x270 >= 0.7980392156862746 -x270 <= 1.0 -x270 <= 0.9980392156862745 -x271 >= 0.0 -x271 >= 0.8960784313725491 -x271 <= 1.0960784313725491 -x271 <= 1.0 -x272 >= 0.0 -x272 >= 0.8960784313725491 -x272 <= 1.0960784313725491 -x272 <= 1.0 -x273 >= 0.0 -x273 >= 0.4490196078431373 -x273 <= 1.0 -x273 <= 0.6490196078431373 +x258 <= 0.1 +x258 <= 0.7372549019607844 +x258 >= -0.2627450980392157 +x258 >= -0.1 +x259 <= 0.1 +x259 <= 0.5529411764705883 +x259 >= -0.4470588235294118 +x259 >= -0.1 +x260 <= 0.1 +x260 <= 0.7176470588235294 +x260 >= -0.2823529411764706 +x260 >= -0.1 +x261 <= 0.1 +x261 <= 0.5529411764705883 +x261 >= -0.4470588235294118 +x261 >= -0.1 +x262 <= 0.3235294117647059 +x262 <= 0.5843137254901961 +x262 >= -0.4156862745098039 +x262 >= 0.12352941176470589 +x263 <= 1.0411764705882354 +x263 <= 1.0509803921568628 +x263 >= 0.050980392156862786 +x263 >= 0.8411764705882353 +x264 <= 0.988235294117647 +x264 <= 1.084313725490196 +x264 >= -0.01176470588235301 +x264 >= 0.884313725490196 +x265 <= 0.3941176470588235 +x265 <= 0.411764705882353 +x265 >= -0.588235294117647 +x265 >= 0.19411764705882353 +x266 <= 0.0039215686274509665 +x266 <= 0.1 +x266 >= -0.996078431372549 +x266 >= -0.1 +x267 <= 0.0039215686274509665 +x267 <= 0.1 +x267 >= -0.996078431372549 +x267 >= -0.1 +x268 <= 0.0039215686274509665 +x268 <= 0.1 +x268 >= -0.996078431372549 +x268 >= -0.1 +x269 <= 0.019607843137254943 +x269 <= 0.1 +x269 >= -0.9803921568627451 +x269 >= -0.1 +x270 <= 0.1 +x270 <= 0.10196078431372546 +x270 >= -0.8980392156862745 +x270 >= -0.1 +x271 <= 0.0039215686274509665 +x271 <= 0.1 +x271 >= -0.996078431372549 +x271 >= -0.1 +x272 <= 0.0039215686274509665 +x272 <= 0.1 +x272 >= -0.996078431372549 +x272 >= -0.1 +x273 <= 0.1 +x273 <= 0.4509803921568627 +x273 >= -0.5490196078431373 +x273 >= -0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 -x290 >= -0.1 -x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 -x291 >= -0.03333333333333333 -x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.16666666666666666 -x292 >= 0.0 -x292 >= 0.15882352941176472 -x292 <= 1.0 -x292 <= 0.3588235294117647 -x293 >= -0.045098039215686274 -x293 >= 0.0 -x293 <= 1.0 -x293 <= 0.15490196078431373 -x294 >= 0.0 -x294 >= 0.1627450980392157 -x294 <= 1.0 -x294 <= 0.3627450980392157 -x295 >= 0.0 -x295 >= 0.1627450980392157 -x295 <= 1.0 -x295 <= 0.3627450980392157 -x296 >= 0.0 -x296 >= 0.1627450980392157 -x296 <= 1.0 -x296 <= 0.3627450980392157 -x297 >= 0.0 -x297 >= 0.13137254901960785 -x297 <= 1.0 -x297 <= 0.33137254901960783 -x298 >= -0.01764705882352941 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.18235294117647058 -x299 >= 0.0 -x299 >= 0.8254901960784314 -x299 <= 1.0254901960784315 -x299 <= 1.0 -x300 >= 0.0 -x300 >= 0.8960784313725491 -x300 <= 1.0960784313725491 -x300 <= 1.0 -x301 >= 0.0 -x301 >= 0.31568627450980397 -x301 <= 1.0 -x301 <= 0.515686274509804 +x290 <= 0.8137254901960784 +x290 <= 1.7137254901960786 +x290 >= 0.6137254901960785 +x290 >= 0.7137254901960784 +x291 <= 1.0960784313725491 +x291 <= 1.9294117647058824 +x291 >= 0.8960784313725491 +x291 >= 0.9294117647058824 +x292 <= 0.5941176470588235 +x292 <= 1.2352941176470589 +x292 >= 0.23529411764705882 +x292 >= 0.3941176470588236 +x293 <= 0.1 +x293 <= 0.9450980392156862 +x293 >= -0.1 +x293 >= -0.054901960784313725 +x294 <= 0.1 +x294 <= 0.7372549019607844 +x294 >= -0.2627450980392157 +x294 >= -0.1 +x295 <= 0.1 +x295 <= 0.7372549019607844 +x295 >= -0.2627450980392157 +x295 >= -0.1 +x296 <= 0.1 +x296 <= 0.7372549019607844 +x296 >= -0.2627450980392157 +x296 >= -0.1 +x297 <= 0.1 +x297 <= 0.7686274509803921 +x297 >= -0.23137254901960785 +x297 >= -0.1 +x298 <= 0.1 +x298 <= 0.9176470588235294 +x298 >= -0.1 +x298 >= -0.08235294117647059 +x299 <= 0.07450980392156858 +x299 <= 0.1 +x299 >= -0.9254901960784314 +x299 >= -0.1 +x300 <= 0.0039215686274509665 +x300 <= 0.1 +x300 >= -0.996078431372549 +x300 >= -0.1 +x301 <= 0.1 +x301 <= 0.584313725490196 +x301 >= -0.41568627450980394 +x301 >= -0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 -x317 >= -0.1 -x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 -x318 >= -0.1 -x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 -x319 >= -0.1 -x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= -0.1 -x320 >= 0.0 -x320 <= 1.0 -x320 <= 0.1 +x317 <= 0.32745098039215687 +x317 <= 1.227450980392157 +x317 >= 0.12745098039215685 +x317 >= 0.22745098039215686 +x318 <= 1.072549019607843 +x318 <= 1.9725490196078432 +x318 >= 0.8725490196078431 +x318 >= 0.9725490196078431 +x319 <= 0.903921568627451 +x319 <= 1.803921568627451 +x319 >= 0.703921568627451 +x319 >= 0.803921568627451 +x320 <= 0.13529411764705881 +x320 <= 1.035294117647059 +x320 >= -0.06470588235294118 +x320 >= 0.03529411764705882 +x321 <= 0.1 +x321 <= 1.0 x321 >= -0.1 x321 >= 0.0 -x321 <= 1.0 -x321 <= 0.1 +x322 <= 0.1 +x322 <= 1.0 x322 >= -0.1 x322 >= 0.0 -x322 <= 1.0 -x322 <= 0.1 +x323 <= 0.1 +x323 <= 1.0 x323 >= -0.1 x323 >= 0.0 -x323 <= 1.0 -x323 <= 0.1 +x324 <= 0.1 +x324 <= 1.0 x324 >= -0.1 x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 +x325 <= 0.1 +x325 <= 1.0 x325 >= -0.1 x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= 0.0 -x326 >= 0.22549019607843138 -x326 <= 1.0 -x326 <= 0.42549019607843136 -x327 >= 0.0 -x327 >= 0.8921568627450981 -x327 <= 1.0921568627450982 -x327 <= 1.0 -x328 >= 0.0 -x328 >= 0.7196078431372549 -x328 <= 1.0 -x328 <= 0.9196078431372549 -x329 >= -0.029411764705882353 -x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.17058823529411765 +x326 <= 0.1 +x326 <= 0.6745098039215687 +x326 >= -0.3254901960784314 +x326 >= -0.1 +x327 <= 0.007843137254901933 +x327 <= 0.1 +x327 >= -0.9921568627450981 +x327 >= -0.1 +x328 <= 0.1 +x328 <= 0.18039215686274512 +x328 >= -0.8196078431372549 +x328 >= -0.1 +x329 <= 0.1 +x329 <= 0.9294117647058824 +x329 >= -0.1 +x329 >= -0.07058823529411765 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 -x344 >= -0.1 -x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 -x345 >= -0.1 -x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 -x346 >= -0.1 -x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= -0.1 -x347 >= 0.0 -x347 <= 1.0 -x347 <= 0.1 +x344 <= 0.11960784313725491 +x344 <= 1.0196078431372548 +x344 >= -0.0803921568627451 +x344 >= 0.0196078431372549 +x345 <= 0.8333333333333333 +x345 <= 1.7333333333333334 +x345 >= 0.6333333333333333 +x345 >= 0.7333333333333333 +x346 <= 1.0960784313725491 +x346 <= 1.996078431372549 +x346 >= 0.8960784313725491 +x346 >= 0.996078431372549 +x347 <= 0.6215686274509804 +x347 <= 1.5215686274509803 +x347 >= 0.42156862745098045 +x347 >= 0.5215686274509804 +x348 <= 0.1 +x348 <= 1.0 x348 >= -0.1 x348 >= 0.0 -x348 <= 1.0 -x348 <= 0.1 +x349 <= 0.1 +x349 <= 1.0 x349 >= -0.1 x349 >= 0.0 -x349 <= 1.0 -x349 <= 0.1 +x350 <= 0.1 +x350 <= 1.0 x350 >= -0.1 x350 >= 0.0 -x350 <= 1.0 -x350 <= 0.1 +x351 <= 0.1 +x351 <= 1.0 x351 >= -0.1 x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.1 +x352 <= 0.1 +x352 <= 1.0 x352 >= -0.1 x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.013725490196078433 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.18627450980392157 -x354 >= 0.0 -x354 >= 0.8137254901960784 -x354 <= 1.0137254901960784 -x354 <= 1.0 -x355 >= 0.0 -x355 >= 0.9 -x355 <= 1.1 -x355 <= 1.0 -x356 >= 0.0 -x356 >= 0.22549019607843138 -x356 <= 1.0 -x356 <= 0.42549019607843136 +x353 <= 0.1 +x353 <= 0.9137254901960784 +x353 >= -0.1 +x353 >= -0.08627450980392157 +x354 <= 0.0862745098039216 +x354 <= 0.1 +x354 >= -0.9137254901960784 +x354 >= -0.1 +x355 <= 0.0 +x355 <= 0.1 +x355 >= -1.0 +x355 >= -0.1 +x356 <= 0.1 +x356 <= 0.6745098039215687 +x356 >= -0.3254901960784314 +x356 >= -0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 -x372 >= -0.1 -x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 -x373 >= -0.1 -x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.1 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1 -x375 >= -0.1 -x375 >= 0.0 -x375 <= 1.0 -x375 <= 0.1 +x372 <= 0.3431372549019608 +x372 <= 1.2431372549019608 +x372 >= 0.14313725490196078 +x372 >= 0.24313725490196078 +x373 <= 1.0960784313725491 +x373 <= 1.996078431372549 +x373 >= 0.8960784313725491 +x373 >= 0.996078431372549 +x374 <= 1.076470588235294 +x374 <= 1.9764705882352942 +x374 >= 0.8764705882352941 +x374 >= 0.9764705882352941 +x375 <= 0.33137254901960783 +x375 <= 1.231372549019608 +x375 >= 0.13137254901960785 +x375 >= 0.23137254901960785 +x376 <= 0.1 +x376 <= 1.0 x376 >= -0.1 x376 >= 0.0 -x376 <= 1.0 -x376 <= 0.1 +x377 <= 0.1 +x377 <= 1.0 x377 >= -0.1 x377 >= 0.0 -x377 <= 1.0 -x377 <= 0.1 +x378 <= 0.1 +x378 <= 1.0 x378 >= -0.1 x378 >= 0.0 -x378 <= 1.0 -x378 <= 0.1 +x379 <= 0.1 +x379 <= 1.0 x379 >= -0.1 x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 +x380 <= 0.1 +x380 <= 1.0 x380 >= -0.1 x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= 0.0 -x381 >= 0.40588235294117647 -x381 <= 1.0 -x381 <= 0.6058823529411764 -x382 >= 0.0 -x382 >= 0.8960784313725491 -x382 <= 1.0960784313725491 -x382 <= 1.0 -x383 >= 0.0 -x383 >= 0.8333333333333334 -x383 <= 1.0333333333333334 -x383 <= 1.0 -x384 >= 0.0 -x384 >= 0.07254901960784313 -x384 <= 1.0 -x384 <= 0.2725490196078431 +x381 <= 0.1 +x381 <= 0.49411764705882355 +x381 >= -0.5058823529411764 +x381 >= -0.1 +x382 <= 0.0039215686274509665 +x382 <= 0.1 +x382 >= -0.996078431372549 +x382 >= -0.1 +x383 <= 0.06666666666666665 +x383 <= 0.1 +x383 >= -0.9333333333333333 +x383 >= -0.1 +x384 <= 0.1 +x384 <= 0.8274509803921568 +x384 >= -0.17254901960784313 +x384 >= -0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 -x399 >= -0.1 -x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 -x400 >= -0.1 -x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 -x401 >= -0.1 -x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= -0.1 -x402 >= 0.0 -x402 <= 1.0 -x402 <= 0.1 +x399 <= 0.2725490196078431 +x399 <= 1.1725490196078432 +x399 >= 0.07254901960784313 +x399 >= 0.17254901960784313 +x400 <= 1.0333333333333334 +x400 <= 1.9333333333333333 +x400 >= 0.8333333333333334 +x400 >= 0.9333333333333333 +x401 <= 1.0960784313725491 +x401 <= 1.996078431372549 +x401 >= 0.8960784313725491 +x401 >= 0.996078431372549 +x402 <= 0.6058823529411764 +x402 <= 1.5058823529411764 +x402 >= 0.40588235294117647 +x402 >= 0.5058823529411764 +x403 <= 0.1 +x403 <= 1.0 x403 >= -0.1 x403 >= 0.0 -x403 <= 1.0 -x403 <= 0.1 +x404 <= 0.1 +x404 <= 1.0 x404 >= -0.1 x404 >= 0.0 -x404 <= 1.0 -x404 <= 0.1 +x405 <= 0.1 +x405 <= 1.0 x405 >= -0.1 x405 >= 0.0 -x405 <= 1.0 -x405 <= 0.1 +x406 <= 0.1 +x406 <= 1.0 x406 >= -0.1 x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 +x407 <= 0.1 +x407 <= 1.0 x407 >= -0.1 x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= 0.0 -x408 >= 0.13137254901960785 -x408 <= 1.0 -x408 <= 0.33137254901960783 -x409 >= 0.0 -x409 >= 0.8764705882352941 -x409 <= 1.076470588235294 -x409 <= 1.0 -x410 >= 0.0 -x410 >= 0.8960784313725491 -x410 <= 1.0960784313725491 -x410 <= 1.0 -x411 >= 0.0 -x411 >= 0.14313725490196078 -x411 <= 1.0 -x411 <= 0.3431372549019608 +x408 <= 0.1 +x408 <= 0.7686274509803921 +x408 >= -0.23137254901960785 +x408 >= -0.1 +x409 <= 0.02352941176470591 +x409 <= 0.1 +x409 >= -0.9764705882352941 +x409 >= -0.1 +x410 <= 0.0039215686274509665 +x410 <= 0.1 +x410 >= -0.996078431372549 +x410 >= -0.1 +x411 <= 0.1 +x411 <= 0.7568627450980392 +x411 >= -0.24313725490196078 +x411 >= -0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 -x427 >= -0.1 -x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 -x428 >= -0.1 -x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= -0.1 -x429 >= 0.0 -x429 <= 1.0 -x429 <= 0.1 -x430 >= -0.1 -x430 >= 0.0 -x430 <= 1.0 -x430 <= 0.1 +x427 <= 0.42549019607843136 +x427 <= 1.3254901960784313 +x427 >= 0.22549019607843138 +x427 >= 0.3254901960784314 +x428 <= 1.1 +x428 <= 2.0 +x428 >= 0.9 +x428 >= 1.0 +x429 <= 1.0137254901960784 +x429 <= 1.9137254901960783 +x429 >= 0.8137254901960784 +x429 >= 0.9137254901960784 +x430 <= 0.18627450980392157 +x430 <= 1.0862745098039215 +x430 >= -0.013725490196078433 +x430 >= 0.08627450980392157 +x431 <= 0.1 +x431 <= 1.0 x431 >= -0.1 x431 >= 0.0 -x431 <= 1.0 -x431 <= 0.1 +x432 <= 0.1 +x432 <= 1.0 x432 >= -0.1 x432 >= 0.0 -x432 <= 1.0 -x432 <= 0.1 +x433 <= 0.1 +x433 <= 1.0 x433 >= -0.1 x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.1 +x434 <= 0.1 +x434 <= 1.0 x434 >= -0.1 x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 +x435 <= 0.1 +x435 <= 1.0 x435 >= -0.1 x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= 0.0 -x436 >= 0.42156862745098045 -x436 <= 1.0 -x436 <= 0.6215686274509804 -x437 >= 0.0 -x437 >= 0.8960784313725491 -x437 <= 1.0960784313725491 -x437 <= 1.0 -x438 >= 0.0 -x438 >= 0.6333333333333333 -x438 <= 1.0 -x438 <= 0.8333333333333333 -x439 >= -0.0803921568627451 -x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.11960784313725491 +x436 <= 0.1 +x436 <= 0.4784313725490196 +x436 >= -0.5215686274509804 +x436 >= -0.1 +x437 <= 0.0039215686274509665 +x437 <= 0.1 +x437 >= -0.996078431372549 +x437 >= -0.1 +x438 <= 0.1 +x438 <= 0.2666666666666667 +x438 >= -0.7333333333333333 +x438 >= -0.1 +x439 <= 0.1 +x439 <= 0.9803921568627451 +x439 >= -0.1 +x439 >= -0.0196078431372549 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 -x454 >= -0.1 -x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 -x455 >= -0.1 -x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.1 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.1 -x457 >= -0.1 -x457 >= 0.0 -x457 <= 1.0 -x457 <= 0.1 +x454 <= 0.17058823529411765 +x454 <= 1.0705882352941176 +x454 >= -0.029411764705882353 +x454 >= 0.07058823529411765 +x455 <= 0.9196078431372549 +x455 <= 1.8196078431372549 +x455 >= 0.7196078431372549 +x455 >= 0.8196078431372549 +x456 <= 1.0921568627450982 +x456 <= 1.992156862745098 +x456 >= 0.8921568627450981 +x456 >= 0.9921568627450981 +x457 <= 0.42549019607843136 +x457 <= 1.3254901960784313 +x457 >= 0.22549019607843138 +x457 >= 0.3254901960784314 +x458 <= 0.1 +x458 <= 1.0 x458 >= -0.1 x458 >= 0.0 -x458 <= 1.0 -x458 <= 0.1 +x459 <= 0.1 +x459 <= 1.0 x459 >= -0.1 x459 >= 0.0 -x459 <= 1.0 -x459 <= 0.1 +x460 <= 0.1 +x460 <= 1.0 x460 >= -0.1 x460 >= 0.0 -x460 <= 1.0 -x460 <= 0.1 +x461 <= 0.1 +x461 <= 1.0 x461 >= -0.1 x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 +x462 <= 0.1 +x462 <= 1.0 x462 >= -0.1 x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.06470588235294118 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.13529411764705881 -x464 >= 0.0 -x464 >= 0.703921568627451 -x464 <= 1.0 -x464 <= 0.903921568627451 -x465 >= 0.0 -x465 >= 0.8725490196078431 -x465 <= 1.072549019607843 -x465 <= 1.0 -x466 >= 0.0 -x466 >= 0.12745098039215685 -x466 <= 1.0 -x466 <= 0.32745098039215687 +x463 <= 0.1 +x463 <= 0.9647058823529412 +x463 >= -0.1 +x463 >= -0.03529411764705882 +x464 <= 0.1 +x464 <= 0.196078431372549 +x464 >= -0.803921568627451 +x464 >= -0.1 +x465 <= 0.027450980392156876 +x465 <= 0.1 +x465 >= -0.9725490196078431 +x465 >= -0.1 +x466 <= 0.1 +x466 <= 0.7725490196078432 +x466 >= -0.22745098039215686 +x466 >= -0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 -x482 >= -0.1 -x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 -x483 >= -0.1 -x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= -0.1 -x484 >= 0.0 -x484 <= 1.0 -x484 <= 0.1 -x485 >= -0.1 -x485 >= 0.0 -x485 <= 1.0 -x485 <= 0.1 -x486 >= -0.1 -x486 >= 0.0 -x486 <= 1.0 -x486 <= 0.1 -x487 >= -0.1 -x487 >= 0.0 -x487 <= 1.0 -x487 <= 0.1 -x488 >= -0.1 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.1 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= 0.0 -x491 >= 0.3941176470588236 -x491 <= 1.0 -x491 <= 0.5941176470588235 -x492 >= 0.0 -x492 >= 0.8960784313725491 -x492 <= 1.0960784313725491 -x492 <= 1.0 -x493 >= 0.0 -x493 >= 0.6137254901960785 -x493 <= 1.0 -x493 <= 0.8137254901960784 +x482 <= 0.515686274509804 +x482 <= 1.415686274509804 +x482 >= 0.31568627450980397 +x482 >= 0.41568627450980394 +x483 <= 1.0960784313725491 +x483 <= 1.996078431372549 +x483 >= 0.8960784313725491 +x483 >= 0.996078431372549 +x484 <= 1.0254901960784315 +x484 <= 1.9254901960784314 +x484 >= 0.8254901960784314 +x484 >= 0.9254901960784314 +x485 <= 0.18235294117647058 +x485 <= 1.0823529411764705 +x485 >= -0.01764705882352941 +x485 >= 0.08235294117647059 +x486 <= 0.33137254901960783 +x486 <= 1.231372549019608 +x486 >= 0.13137254901960785 +x486 >= 0.23137254901960785 +x487 <= 0.3627450980392157 +x487 <= 1.2627450980392156 +x487 >= 0.1627450980392157 +x487 >= 0.2627450980392157 +x488 <= 0.3627450980392157 +x488 <= 1.2627450980392156 +x488 >= 0.1627450980392157 +x488 >= 0.2627450980392157 +x489 <= 0.3627450980392157 +x489 <= 1.2627450980392156 +x489 >= 0.1627450980392157 +x489 >= 0.2627450980392157 +x490 <= 0.15490196078431373 +x490 <= 1.0549019607843138 +x490 >= -0.045098039215686274 +x490 >= 0.054901960784313725 +x491 <= 0.3588235294117647 +x491 <= 0.7647058823529411 +x491 >= -0.23529411764705882 +x491 >= 0.15882352941176472 +x492 <= 0.07058823529411763 +x492 <= 0.16666666666666666 +x492 >= -0.9294117647058824 +x492 >= -0.03333333333333333 +x493 <= 0.1 +x493 <= 0.28627450980392155 +x493 >= -0.7137254901960784 +x493 >= -0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 -x510 >= -0.1 -x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 -x511 >= -0.1 -x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= -0.1 -x512 >= 0.0 -x512 <= 1.0 -x512 <= 0.1 -x513 >= -0.1 -x513 >= 0.0 -x513 <= 1.0 -x513 <= 0.1 -x514 >= -0.1 -x514 >= 0.0 -x514 <= 1.0 -x514 <= 0.1 -x515 >= -0.1 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= 0.0 -x518 >= 0.19411764705882353 -x518 <= 1.0 -x518 <= 0.3941176470588235 -x519 >= 0.0 -x519 >= 0.884313725490196 -x519 <= 1.084313725490196 -x519 <= 1.0 -x520 >= 0.0 -x520 >= 0.8411764705882353 -x520 <= 1.0411764705882354 -x520 <= 1.0 -x521 >= 0.0 -x521 >= 0.12352941176470589 -x521 <= 1.0 -x521 <= 0.3235294117647059 -x522 >= -0.1 -x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 -x523 >= -0.1 -x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 -x524 >= -0.1 -x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 -x525 >= -0.1 -x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x510 <= 0.6490196078431373 +x510 <= 1.5490196078431373 +x510 >= 0.4490196078431373 +x510 >= 0.5490196078431373 +x511 <= 1.0960784313725491 +x511 <= 1.996078431372549 +x511 >= 0.8960784313725491 +x511 >= 0.996078431372549 +x512 <= 1.0960784313725491 +x512 <= 1.996078431372549 +x512 >= 0.8960784313725491 +x512 >= 0.996078431372549 +x513 <= 0.9980392156862745 +x513 <= 1.8980392156862744 +x513 >= 0.7980392156862746 +x513 >= 0.8980392156862745 +x514 <= 1.080392156862745 +x514 <= 1.9803921568627452 +x514 >= 0.8803921568627451 +x514 >= 0.9803921568627451 +x515 <= 1.0960784313725491 +x515 <= 1.996078431372549 +x515 >= 0.8960784313725491 +x515 >= 0.996078431372549 +x516 <= 1.0960784313725491 +x516 <= 1.996078431372549 +x516 >= 0.8960784313725491 +x516 >= 0.996078431372549 +x517 <= 1.0960784313725491 +x517 <= 1.996078431372549 +x517 >= 0.8960784313725491 +x517 >= 0.996078431372549 +x518 <= 0.9823529411764705 +x518 <= 1.588235294117647 +x518 >= 0.588235294117647 +x518 >= 0.7823529411764706 +x519 <= 1.011764705882353 +x519 <= 1.0960784313725491 +x519 >= 0.01176470588235301 +x519 >= 0.8960784313725491 +x520 <= 0.9490196078431372 +x520 <= 0.9901960784313725 +x520 >= -0.050980392156862786 +x520 >= 0.7901960784313725 +x521 <= 0.7392156862745097 +x521 <= 1.4156862745098038 +x521 >= 0.4156862745098039 +x521 >= 0.5392156862745098 +x522 <= 0.5470588235294118 +x522 <= 1.4470588235294117 +x522 >= 0.3470588235294118 +x522 >= 0.4470588235294118 +x523 <= 0.38235294117647056 +x523 <= 1.2823529411764705 +x523 >= 0.18235294117647058 +x523 >= 0.2823529411764706 +x524 <= 0.5470588235294118 +x524 <= 1.4470588235294117 +x524 >= 0.3470588235294118 +x524 >= 0.4470588235294118 +x525 <= 0.3627450980392157 +x525 <= 1.2627450980392156 +x525 >= 0.1627450980392157 +x525 >= 0.2627450980392157 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 -x538 >= -0.1 -x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 -x539 >= -0.1 -x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= -0.1 -x540 >= 0.0 -x540 <= 1.0 -x540 <= 0.1 -x541 >= -0.1 -x541 >= 0.0 -x541 <= 1.0 -x541 <= 0.1 -x542 >= -0.1 -x542 >= 0.0 -x542 <= 1.0 -x542 <= 0.1 -x543 >= -0.1 -x543 >= 0.0 -x543 <= 1.0 -x543 <= 0.1 -x544 >= -0.1 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1 -x545 >= -0.025490196078431372 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.17450980392156862 -x546 >= 0.0 -x546 >= 0.7666666666666667 -x546 <= 1.0 -x546 <= 0.9666666666666667 -x547 >= 0.0 -x547 >= 0.8960784313725491 -x547 <= 1.0960784313725491 -x547 <= 1.0 -x548 >= 0.0 -x548 >= 0.5509803921568628 -x548 <= 1.0 -x548 <= 0.7509803921568627 -x549 >= -0.1 -x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.1 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.1 -x551 >= -0.1 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1 -x552 >= -0.1 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1 -x553 >= -0.1 -x553 >= 0.0 -x553 <= 1.0 -x553 <= 0.1 +x538 <= 0.30392156862745096 +x538 <= 1.203921568627451 +x538 >= 0.10392156862745097 +x538 >= 0.20392156862745098 +x539 <= 0.7666666666666666 +x539 <= 1.6666666666666665 +x539 >= 0.5666666666666667 +x539 >= 0.6666666666666666 +x540 <= 0.8764705882352941 +x540 <= 1.776470588235294 +x540 >= 0.6764705882352942 +x540 >= 0.7764705882352941 +x541 <= 0.8764705882352941 +x541 <= 1.776470588235294 +x541 >= 0.6764705882352942 +x541 >= 0.7764705882352941 +x542 <= 0.8764705882352941 +x542 <= 1.776470588235294 +x542 >= 0.6764705882352942 +x542 >= 0.7764705882352941 +x543 <= 0.8764705882352941 +x543 <= 1.776470588235294 +x543 >= 0.6764705882352942 +x543 >= 0.7764705882352941 +x544 <= 0.8764705882352941 +x544 <= 1.776470588235294 +x544 >= 0.6764705882352942 +x544 >= 0.7764705882352941 +x545 <= 0.8764705882352941 +x545 <= 1.7019607843137254 +x545 >= 0.6764705882352942 +x545 >= 0.7019607843137255 +x546 <= 0.8764705882352941 +x546 <= 0.9098039215686274 +x546 >= -0.09019607843137256 +x546 >= 0.6764705882352942 +x547 <= 0.7803921568627451 +x547 <= 0.8764705882352941 +x547 >= -0.2196078431372549 +x547 >= 0.6764705882352942 +x548 <= 1.0450980392156863 +x548 <= 1.2941176470588234 +x548 >= 0.2941176470588235 +x548 >= 0.8450980392156863 +x549 <= 1.0960784313725491 +x549 <= 1.996078431372549 +x549 >= 0.8960784313725491 +x549 >= 0.996078431372549 +x550 <= 1.0960784313725491 +x550 <= 1.996078431372549 +x550 >= 0.8960784313725491 +x550 >= 0.996078431372549 +x551 <= 1.0960784313725491 +x551 <= 1.996078431372549 +x551 >= 0.8960784313725491 +x551 >= 0.996078431372549 +x552 <= 1.0960784313725491 +x552 <= 1.996078431372549 +x552 >= 0.8960784313725491 +x552 >= 0.996078431372549 +x553 <= 0.9705882352941176 +x553 <= 1.8705882352941177 +x553 >= 0.7705882352941177 +x553 >= 0.8705882352941177 +x554 <= 0.1 +x554 <= 1.0 x554 >= -0.1 x554 >= 0.0 -x554 <= 1.0 -x554 <= 0.1 +x555 <= 0.1 +x555 <= 1.0 x555 >= -0.1 x555 >= 0.0 -x555 <= 1.0 -x555 <= 0.1 +x556 <= 0.1 +x556 <= 1.0 x556 >= -0.1 x556 >= 0.0 -x556 <= 1.0 -x556 <= 0.1 +x557 <= 0.1 +x557 <= 1.0 x557 >= -0.1 x557 >= 0.0 -x557 <= 1.0 -x557 <= 0.1 +x558 <= 0.1 +x558 <= 1.0 x558 >= -0.1 x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 +x568 <= 0.1 +x568 <= 1.0 x568 >= -0.1 x568 >= 0.0 -x568 <= 1.0 -x568 <= 0.1 +x569 <= 0.1 +x569 <= 1.0 x569 >= -0.1 x569 >= 0.0 -x569 <= 1.0 -x569 <= 0.1 +x570 <= 0.1 +x570 <= 1.0 x570 >= -0.1 x570 >= 0.0 -x570 <= 1.0 -x570 <= 0.1 +x571 <= 0.1 +x571 <= 1.0 x571 >= -0.1 x571 >= 0.0 -x571 <= 1.0 -x571 <= 0.1 -x572 >= -0.08823529411764706 -x572 >= 0.0 -x572 <= 1.0 -x572 <= 0.11176470588235295 -x573 >= 0.0 -x573 >= 0.696078431372549 -x573 <= 1.0 -x573 <= 0.896078431372549 -x574 >= 0.0 -x574 >= 0.8960784313725491 -x574 <= 1.0960784313725491 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.7588235294117647 -x575 <= 1.0 -x575 <= 0.9588235294117646 -x576 >= 0.0 -x576 >= 0.03725490196078433 -x576 <= 1.0 -x576 <= 0.23725490196078433 -x577 >= -0.1 -x577 >= 0.0 -x577 <= 1.0 -x577 <= 0.1 -x578 >= -0.1 -x578 >= 0.0 -x578 <= 1.0 -x578 <= 0.1 -x579 >= -0.1 -x579 >= 0.0 -x579 <= 1.0 -x579 <= 0.1 -x580 >= -0.1 -x580 >= 0.0 -x580 <= 1.0 -x580 <= 0.1 -x581 >= -0.1 -x581 >= 0.0 -x581 <= 1.0 -x581 <= 0.1 +x572 <= 0.1 +x572 <= 0.9882352941176471 +x572 >= -0.1 +x572 >= -0.011764705882352941 +x573 <= 0.1 +x573 <= 0.20392156862745103 +x573 >= -0.796078431372549 +x573 >= -0.1 +x574 <= 0.0039215686274509665 +x574 <= 0.1 +x574 >= -0.996078431372549 +x574 >= -0.1 +x575 <= 0.1 +x575 <= 0.14117647058823535 +x575 >= -0.8588235294117647 +x575 >= -0.1 +x576 <= 0.2411764705882353 +x576 <= 1.003921568627451 +x576 >= 0.0039215686274509665 +x576 >= 0.041176470588235294 +x577 <= 0.3352941176470588 +x577 <= 1.2352941176470589 +x577 >= 0.13529411764705881 +x577 >= 0.23529411764705882 +x578 <= 0.692156862745098 +x578 <= 1.5921568627450982 +x578 >= 0.49215686274509807 +x578 >= 0.592156862745098 +x579 <= 0.7235294117647059 +x579 <= 1.6235294117647059 +x579 >= 0.5235294117647059 +x579 >= 0.6235294117647059 +x580 <= 0.8254901960784313 +x580 <= 1.7254901960784315 +x580 >= 0.6254901960784314 +x580 >= 0.7254901960784313 +x581 <= 0.4294117647058823 +x581 <= 1.3294117647058823 +x581 >= 0.22941176470588234 +x581 >= 0.32941176470588235 +x582 <= 0.1 +x582 <= 1.0 x582 >= -0.1 x582 >= 0.0 -x582 <= 1.0 -x582 <= 0.1 +x583 <= 0.1 +x583 <= 1.0 x583 >= -0.1 x583 >= 0.0 -x583 <= 1.0 -x583 <= 0.1 +x584 <= 0.1 +x584 <= 1.0 x584 >= -0.1 x584 >= 0.0 -x584 <= 1.0 -x584 <= 0.1 +x585 <= 0.1 +x585 <= 1.0 x585 >= -0.1 x585 >= 0.0 -x585 <= 1.0 -x585 <= 0.1 +x586 <= 0.1 +x586 <= 1.0 x586 >= -0.1 x586 >= 0.0 -x586 <= 1.0 -x586 <= 0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 +x596 <= 0.1 +x596 <= 1.0 x596 >= -0.1 x596 >= 0.0 -x596 <= 1.0 -x596 <= 0.1 +x597 <= 0.1 +x597 <= 1.0 x597 >= -0.1 x597 >= 0.0 -x597 <= 1.0 -x597 <= 0.1 +x598 <= 0.1 +x598 <= 1.0 x598 >= -0.1 x598 >= 0.0 -x598 <= 1.0 -x598 <= 0.1 +x599 <= 0.1 +x599 <= 1.0 x599 >= -0.1 x599 >= 0.0 -x599 <= 1.0 -x599 <= 0.1 -x600 >= 0.0 -x600 >= 0.049019607843137254 -x600 <= 1.0 -x600 <= 0.24901960784313726 -x601 >= 0.0 -x601 >= 0.8960784313725491 -x601 <= 1.0960784313725491 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8960784313725491 -x602 <= 1.0960784313725491 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.20196078431372547 -x603 <= 1.0 -x603 <= 0.40196078431372545 +x600 <= 0.1 +x600 <= 0.8509803921568627 +x600 >= -0.14901960784313725 +x600 >= -0.1 +x601 <= 0.0039215686274509665 +x601 <= 0.1 +x601 >= -0.996078431372549 +x601 >= -0.1 +x602 <= 0.0039215686274509665 +x602 <= 0.1 +x602 >= -0.996078431372549 +x602 >= -0.1 +x603 <= 0.1 +x603 <= 0.6980392156862745 +x603 >= -0.30196078431372547 +x603 >= -0.1 +x604 <= 0.1 +x604 <= 1.0 x604 >= -0.1 x604 >= 0.0 -x604 <= 1.0 -x604 <= 0.1 +x605 <= 0.1 +x605 <= 1.0 x605 >= -0.1 x605 >= 0.0 -x605 <= 1.0 -x605 <= 0.1 +x606 <= 0.1 +x606 <= 1.0 x606 >= -0.1 x606 >= 0.0 -x606 <= 1.0 -x606 <= 0.1 +x607 <= 0.1 +x607 <= 1.0 x607 >= -0.1 x607 >= 0.0 -x607 <= 1.0 -x607 <= 0.1 +x608 <= 0.1 +x608 <= 1.0 x608 >= -0.1 x608 >= 0.0 -x608 <= 1.0 -x608 <= 0.1 +x609 <= 0.1 +x609 <= 1.0 x609 >= -0.1 x609 >= 0.0 -x609 <= 1.0 -x609 <= 0.1 +x610 <= 0.1 +x610 <= 1.0 x610 >= -0.1 x610 >= 0.0 -x610 <= 1.0 -x610 <= 0.1 +x611 <= 0.1 +x611 <= 1.0 x611 >= -0.1 x611 >= 0.0 -x611 <= 1.0 -x611 <= 0.1 +x612 <= 0.1 +x612 <= 1.0 x612 >= -0.1 x612 >= 0.0 -x612 <= 1.0 -x612 <= 0.1 +x613 <= 0.1 +x613 <= 1.0 x613 >= -0.1 x613 >= 0.0 -x613 <= 1.0 -x613 <= 0.1 +x614 <= 0.1 +x614 <= 1.0 x614 >= -0.1 x614 >= 0.0 -x614 <= 1.0 -x614 <= 0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 +x625 <= 0.1 +x625 <= 1.0 x625 >= -0.1 x625 >= 0.0 -x625 <= 1.0 -x625 <= 0.1 +x626 <= 0.1 +x626 <= 1.0 x626 >= -0.1 x626 >= 0.0 -x626 <= 1.0 -x626 <= 0.1 -x627 >= 0.0 -x627 >= 0.021568627450980392 -x627 <= 1.0 -x627 <= 0.22156862745098038 -x628 >= 0.0 -x628 >= 0.7784313725490196 -x628 <= 1.0 -x628 <= 0.9784313725490196 -x629 >= 0.0 -x629 >= 0.8960784313725491 -x629 <= 1.0960784313725491 -x629 <= 1.0 -x630 >= 0.0 -x630 >= 0.3509803921568628 -x630 <= 1.0 -x630 <= 0.5509803921568628 -x631 >= -0.09607843137254903 -x631 >= 0.0 -x631 <= 1.0 -x631 <= 0.10392156862745099 +x627 <= 0.1 +x627 <= 0.8784313725490196 +x627 >= -0.12156862745098039 +x627 >= -0.1 +x628 <= 0.1 +x628 <= 0.1215686274509804 +x628 >= -0.8784313725490196 +x628 >= -0.1 +x629 <= 0.0039215686274509665 +x629 <= 0.1 +x629 >= -0.996078431372549 +x629 >= -0.1 +x630 <= 0.1 +x630 <= 0.5490196078431373 +x630 >= -0.45098039215686275 +x630 >= -0.1 +x631 <= 0.1 +x631 <= 0.996078431372549 +x631 >= -0.1 +x631 >= -0.00392156862745098 +x632 <= 0.1 +x632 <= 1.0 x632 >= -0.1 x632 >= 0.0 -x632 <= 1.0 -x632 <= 0.1 +x633 <= 0.1 +x633 <= 1.0 x633 >= -0.1 x633 >= 0.0 -x633 <= 1.0 -x633 <= 0.1 +x634 <= 0.1 +x634 <= 1.0 x634 >= -0.1 x634 >= 0.0 -x634 <= 1.0 -x634 <= 0.1 +x635 <= 0.1 +x635 <= 1.0 x635 >= -0.1 x635 >= 0.0 -x635 <= 1.0 -x635 <= 0.1 +x636 <= 0.1 +x636 <= 1.0 x636 >= -0.1 x636 >= 0.0 -x636 <= 1.0 -x636 <= 0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 +x654 <= 0.1 +x654 <= 1.0 x654 >= -0.1 x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= 0.0 -x655 >= 0.42156862745098045 -x655 <= 1.0 -x655 <= 0.6215686274509804 -x656 >= 0.0 -x656 >= 0.8960784313725491 -x656 <= 1.0960784313725491 -x656 <= 1.0 -x657 >= 0.0 -x657 >= 0.8960784313725491 -x657 <= 1.0960784313725491 -x657 <= 1.0 -x658 >= 0.0 -x658 >= 0.10392156862745097 -x658 <= 1.0 -x658 <= 0.30392156862745096 +x655 <= 0.1 +x655 <= 0.4784313725490196 +x655 >= -0.5215686274509804 +x655 >= -0.1 +x656 <= 0.0039215686274509665 +x656 <= 0.1 +x656 >= -0.996078431372549 +x656 >= -0.1 +x657 <= 0.0039215686274509665 +x657 <= 0.1 +x657 >= -0.996078431372549 +x657 >= -0.1 +x658 <= 0.1 +x658 <= 0.7960784313725491 +x658 >= -0.20392156862745098 +x658 >= -0.1 +x659 <= 0.1 +x659 <= 1.0 x659 >= -0.1 x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 +x660 <= 0.1 +x660 <= 1.0 x660 >= -0.1 x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 +x661 <= 0.1 +x661 <= 1.0 x661 >= -0.1 x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 +x662 <= 0.1 +x662 <= 1.0 x662 >= -0.1 x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 -x682 >= 0.0 -x682 >= 0.1392156862745098 -x682 <= 1.0 -x682 <= 0.3392156862745098 -x683 >= 0.0 -x683 >= 0.8490196078431372 -x683 <= 1.0490196078431373 -x683 <= 1.0 -x684 >= 0.0 -x684 >= 0.8960784313725491 -x684 <= 1.0960784313725491 -x684 <= 1.0 -x685 >= 0.0 -x685 >= 0.8960784313725491 -x685 <= 1.0960784313725491 -x685 <= 1.0 -x686 >= 0.0 -x686 >= 0.10392156862745097 -x686 <= 1.0 -x686 <= 0.30392156862745096 +x682 <= 0.1 +x682 <= 0.7607843137254902 +x682 >= -0.23921568627450981 +x682 >= -0.1 +x683 <= 0.050980392156862786 +x683 <= 0.1 +x683 >= -0.9490196078431372 +x683 >= -0.1 +x684 <= 0.0039215686274509665 +x684 <= 0.1 +x684 >= -0.996078431372549 +x684 >= -0.1 +x685 <= 0.0039215686274509665 +x685 <= 0.1 +x685 >= -0.996078431372549 +x685 >= -0.1 +x686 <= 0.1 +x686 <= 0.7960784313725491 +x686 >= -0.20392156862745098 +x686 >= -0.1 +x687 <= 0.1 +x687 <= 1.0 x687 >= -0.1 x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 +x688 <= 0.1 +x688 <= 1.0 x688 >= -0.1 x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 +x689 <= 0.1 +x689 <= 1.0 x689 >= -0.1 x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 -x710 >= 0.0 -x710 >= 0.37450980392156863 -x710 <= 1.0 -x710 <= 0.5745098039215686 -x711 >= 0.0 -x711 >= 0.8960784313725491 -x711 <= 1.0960784313725491 -x711 <= 1.0 -x712 >= 0.0 -x712 >= 0.8960784313725491 -x712 <= 1.0960784313725491 -x712 <= 1.0 -x713 >= 0.0 -x713 >= 0.7588235294117647 -x713 <= 1.0 -x713 <= 0.9588235294117646 -x714 >= 0.0 -x714 >= 0.056862745098039215 -x714 <= 1.0 -x714 <= 0.2568627450980392 +x710 <= 0.1 +x710 <= 0.5254901960784314 +x710 >= -0.4745098039215686 +x710 >= -0.1 +x711 <= 0.0039215686274509665 +x711 <= 0.1 +x711 >= -0.996078431372549 +x711 >= -0.1 +x712 <= 0.0039215686274509665 +x712 <= 0.1 +x712 >= -0.996078431372549 +x712 >= -0.1 +x713 <= 0.1 +x713 <= 0.14117647058823535 +x713 >= -0.8588235294117647 +x713 >= -0.1 +x714 <= 0.1 +x714 <= 0.8431372549019608 +x714 >= -0.1568627450980392 +x714 >= -0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 -x738 >= 0.0 -x738 >= 0.37450980392156863 -x738 <= 1.0 -x738 <= 0.5745098039215686 -x739 >= 0.0 -x739 >= 0.8960784313725491 -x739 <= 1.0960784313725491 -x739 <= 1.0 -x740 >= 0.0 -x740 >= 0.711764705882353 -x740 <= 1.0 -x740 <= 0.9117647058823529 -x741 >= -0.029411764705882353 -x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.17058823529411765 +x738 <= 0.1 +x738 <= 0.5254901960784314 +x738 >= -0.4745098039215686 +x738 >= -0.1 +x739 <= 0.0039215686274509665 +x739 <= 0.1 +x739 >= -0.996078431372549 +x739 >= -0.1 +x740 <= 0.1 +x740 <= 0.18823529411764706 +x740 >= -0.8117647058823529 +x740 >= -0.1 +x741 <= 0.1 +x741 <= 0.9294117647058824 +x741 >= -0.1 +x741 >= -0.07058823529411765 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y7 -y9 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0.vcl-plan.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0.vcl-plan.golden index 981894f9f..7af744e69 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0.vcl-plan.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!0.vcl-plan.golden @@ -6,70 +6,22 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 - ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { - "dimensions": [ - 28, - 28 - ], - "constantValue": [ + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -879,27 +831,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -991,67 +943,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -1103,67 +1055,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -1235,47 +1187,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -1375,19 +1327,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -1483,19 +1435,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -1595,19 +1547,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -1703,19 +1655,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -1815,19 +1767,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -1923,19 +1875,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -2035,15 +1987,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -2143,19 +2095,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -2251,19 +2203,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -2359,23 +2311,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -2471,19 +2423,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -2579,23 +2531,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -2691,19 +2643,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -2799,23 +2751,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -2911,23 +2863,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -3023,19 +2975,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -3207,589 +3159,13230 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + } + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 + ] } } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "robust", "propertyIndices": [ 0 - ] + ], + "propertyID": 0 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 - ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { - "dimensions": [ - 28, - 28 - ], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 28, + 28 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 }, { "numerator": 0, @@ -4160,27 +16753,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -4272,67 +16865,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -4384,67 +16977,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -4516,47 +17109,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -4656,19 +17249,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -4764,19 +17357,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -4876,19 +17469,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -4984,19 +17577,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -5096,19 +17689,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -5204,19 +17797,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -5316,15 +17909,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -5424,19 +18017,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -5532,19 +18125,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -5640,23 +18233,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -5752,19 +18345,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -5860,23 +18453,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -5972,19 +18565,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -6080,23 +18673,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -6192,23 +18785,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -6304,19 +18897,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -6488,150 +19081,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 3 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -7441,27 +32675,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -7553,67 +32787,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -7665,67 +32899,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -7797,47 +33031,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -7937,19 +33171,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -8045,19 +33279,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -8157,19 +33391,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -8265,19 +33499,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -8377,19 +33611,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -8485,19 +33719,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -8597,15 +33831,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -8705,19 +33939,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -8813,19 +34047,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -8921,23 +34155,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -9033,19 +34267,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -9141,23 +34375,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -9253,19 +34487,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -9361,23 +34595,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -9473,23 +34707,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -9585,19 +34819,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -9769,150 +35003,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 3 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 4 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -10722,27 +48597,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -10834,67 +48709,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -10946,67 +48821,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -11078,47 +48953,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -11218,19 +49093,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -11326,19 +49201,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -11438,19 +49313,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -11546,19 +49421,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -11658,19 +49533,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -11766,19 +49641,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -11878,15 +49753,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -11986,19 +49861,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -12094,19 +49969,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -12202,23 +50077,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -12314,19 +50189,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -12422,23 +50297,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -12534,19 +50409,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -12642,23 +50517,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -12754,23 +50629,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -12866,19 +50741,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -13050,150 +50925,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 4 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 5 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -14003,27 +64519,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -14115,67 +64631,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -14227,67 +64743,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -14359,47 +64875,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -14499,19 +65015,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -14607,19 +65123,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -14719,19 +65235,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -14827,19 +65343,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -14939,19 +65455,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -15047,19 +65563,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -15159,15 +65675,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -15267,19 +65783,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -15375,19 +65891,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -15483,23 +65999,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -15595,19 +66111,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -15703,23 +66219,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -15815,19 +66331,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -15923,23 +66439,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -16035,23 +66551,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -16147,19 +66663,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -16331,150 +66847,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 5 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 6 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -17284,27 +80441,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -17396,67 +80553,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -17508,67 +80665,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -17640,47 +80797,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -17780,19 +80937,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -17888,19 +81045,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -18000,19 +81157,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -18108,19 +81265,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -18220,19 +81377,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -18328,19 +81485,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -18440,15 +81597,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -18548,19 +81705,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -18656,19 +81813,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -18764,23 +81921,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -18876,19 +82033,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -18984,23 +82141,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -19096,19 +82253,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -19204,23 +82361,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -19316,23 +82473,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -19428,19 +82585,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -19612,150 +82769,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 6 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 7 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -20565,27 +96363,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -20677,67 +96475,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -20789,67 +96587,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -20921,47 +96719,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -21061,19 +96859,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -21169,19 +96967,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -21281,19 +97079,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -21389,19 +97187,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -21501,19 +97299,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -21609,19 +97407,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -21721,15 +97519,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -21829,19 +97627,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -21937,19 +97735,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -22045,23 +97843,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -22157,19 +97955,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -22265,23 +98063,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -22377,19 +98175,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -22485,23 +98283,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -22597,23 +98395,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -22709,19 +98507,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -22893,150 +98691,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 7 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 8 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -23846,27 +112285,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -23958,67 +112397,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -24070,67 +112509,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -24202,47 +112641,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -24342,19 +112781,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -24450,19 +112889,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -24562,19 +113001,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -24670,19 +113109,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -24782,19 +113221,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -24890,19 +113329,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -25002,15 +113441,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -25110,19 +113549,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -25218,19 +113657,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -25326,23 +113765,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -25438,19 +113877,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -25546,23 +113985,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -25658,19 +114097,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -25766,23 +114205,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -25878,23 +114317,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -25990,19 +114429,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -26174,150 +114613,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 8 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 0 - ] - }, - 9 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -27127,27 +128207,27 @@ "denominator": 1 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 18014398509481984 }, { - "numerator": 6534634753439543, + "numerator": -6534634753439543, "denominator": 9007199254740992 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 5333674852807411, + "numerator": -5333674852807411, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 18014398509481984 }, { @@ -27239,67 +128319,67 @@ "denominator": 1 }, { - "numerator": 1960390426031863, + "numerator": -1960390426031863, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4256343177240351, + "numerator": -4256343177240351, "denominator": 4503599627370496 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 6004799503160661, + "numerator": -6004799503160661, "denominator": 9007199254740992 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -27351,67 +128431,67 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 9007199254740992 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 18014398509481984 }, { - "numerator": 1439385763257629, + "numerator": -1439385763257629, "denominator": 2251799813685248 }, { - "numerator": 2004543363555103, + "numerator": -2004543363555103, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 1986882188545807, + "numerator": -1986882188545807, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 8088818154257597, + "numerator": -8088818154257597, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -27483,47 +128563,47 @@ "denominator": 1 }, { - "numerator": 4803839602528529, + "numerator": -4803839602528529, "denominator": 72057594037927936 }, { - "numerator": 4662550202454161, + "numerator": -4662550202454161, "denominator": 18014398509481984 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 36028797018963968 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 18014398509481984 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 72057594037927936 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7488338203941531, + "numerator": -7488338203941531, "denominator": 18014398509481984 }, { @@ -27623,19 +128703,19 @@ "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -27731,19 +128811,19 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 36028797018963968 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 18014398509481984 }, { @@ -27843,19 +128923,19 @@ "denominator": 1 }, { - "numerator": 284786447024899, + "numerator": -284786447024899, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 4203359652212463, + "numerator": -4203359652212463, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 18014398509481984 }, { @@ -27951,19 +129031,19 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 18014398509481984 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 36028797018963968 }, { @@ -28063,19 +129143,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6605279453476727, + "numerator": -6605279453476727, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -28171,19 +129251,19 @@ "denominator": 1 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 72057594037927936 }, { - "numerator": 3620540876905693, + "numerator": -3620540876905693, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 36028797018963968 }, { @@ -28283,15 +129363,15 @@ "denominator": 1 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 562949953421312 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 6428667703383767, + "numerator": -6428667703383767, "denominator": 9007199254740992 }, { @@ -28391,19 +129471,19 @@ "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 4503599627370496 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -28499,19 +129579,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 1951559838527215, + "numerator": -1951559838527215, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { @@ -28607,23 +129687,23 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 72057594037927936 }, { - "numerator": 7170437053774201, + "numerator": -7170437053774201, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -28719,19 +129799,19 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 36028797018963968 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { @@ -28827,23 +129907,23 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 1978051601041159, + "numerator": -1978051601041159, "denominator": 2251799813685248 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 8124140504276189, + "numerator": -8124140504276189, "denominator": 18014398509481984 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 72057594037927936 }, { @@ -28939,19 +130019,19 @@ "denominator": 1 }, { - "numerator": 4697872552472753, + "numerator": -4697872552472753, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -29047,23 +130127,23 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 36028797018963968 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 4503599627370496 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { @@ -29159,23 +130239,23 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 7735594654071675, + "numerator": -7735594654071675, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 9007199254740992 }, { @@ -29271,19 +130351,19 @@ "denominator": 1 }, { - "numerator": 4274004352249647, + "numerator": -4274004352249647, "denominator": 9007199254740992 }, { - "numerator": 280371153272575, + "numerator": -280371153272575, "denominator": 281474976710656 }, { - "numerator": 3655863226924285, + "numerator": -3655863226924285, "denominator": 4503599627370496 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -29455,86 +130535,12775 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + } + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 0 + ], + "propertyID": 0 + }, + 9 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, + "networkEntries": [ + { "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 28, + 28 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query1.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query1.txt.golden index 7dfea208c..ab8fc75d5 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query1.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query1.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y0 +y2 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y0 +y2 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query2.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query2.txt.golden index 6a9f45d0a..0d7021a39 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query2.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query2.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +-y1 +y2 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 --y1 +y2 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query3.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query3.txt.golden index aa2f86421..e3fb1900d 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query3.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query3.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y3 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y2 -y3 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query4.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query4.txt.golden index d2846e0cf..9c26c4f6a 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query4.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query4.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y4 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y2 -y4 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query5.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query5.txt.golden index aa48e74b9..d02dfd594 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query5.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query5.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y5 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y2 -y5 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query6.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query6.txt.golden index c031baa37..3a3a225e9 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query6.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query6.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y6 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y2 -y6 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query7.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query7.txt.golden index 28f40ff80..1ce00b92b 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query7.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query7.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y7 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y2 -y7 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query8.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query8.txt.golden index a2c3d942d..fd82d5722 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query8.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query8.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y8 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y2 -y8 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query9.txt.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query9.txt.golden index b088415b3..be0395c59 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query9.txt.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1-query9.txt.golden @@ -2,3141 +2,3141 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev ++y2 -y9 <= 0.0 +x0 <= 0.1 +x0 <= 1.0 x0 >= -0.1 x0 >= 0.0 -x0 <= 1.0 -x0 <= 0.1 +x1 <= 0.1 +x1 <= 1.0 x1 >= -0.1 x1 >= 0.0 -x1 <= 1.0 -x1 <= 0.1 +x2 <= 0.1 +x2 <= 1.0 x2 >= -0.1 x2 >= 0.0 -x2 <= 1.0 -x2 <= 0.1 +x3 <= 0.1 +x3 <= 1.0 x3 >= -0.1 x3 >= 0.0 -x3 <= 1.0 -x3 <= 0.1 +x4 <= 0.1 +x4 <= 1.0 x4 >= -0.1 x4 >= 0.0 -x4 <= 1.0 -x4 <= 0.1 +x5 <= 0.1 +x5 <= 1.0 x5 >= -0.1 x5 >= 0.0 -x5 <= 1.0 -x5 <= 0.1 +x6 <= 0.1 +x6 <= 1.0 x6 >= -0.1 x6 >= 0.0 -x6 <= 1.0 -x6 <= 0.1 +x7 <= 0.1 +x7 <= 1.0 x7 >= -0.1 x7 >= 0.0 -x7 <= 1.0 -x7 <= 0.1 +x8 <= 0.1 +x8 <= 1.0 x8 >= -0.1 x8 >= 0.0 -x8 <= 1.0 -x8 <= 0.1 +x9 <= 0.1 +x9 <= 1.0 x9 >= -0.1 x9 >= 0.0 -x9 <= 1.0 -x9 <= 0.1 +x10 <= 0.1 +x10 <= 1.0 x10 >= -0.1 x10 >= 0.0 -x10 <= 1.0 -x10 <= 0.1 +x11 <= 0.1 +x11 <= 1.0 x11 >= -0.1 x11 >= 0.0 -x11 <= 1.0 -x11 <= 0.1 +x12 <= 0.1 +x12 <= 1.0 x12 >= -0.1 x12 >= 0.0 -x12 <= 1.0 -x12 <= 0.1 +x13 <= 0.1 +x13 <= 1.0 x13 >= -0.1 x13 >= 0.0 -x13 <= 1.0 -x13 <= 0.1 +x14 <= 0.1 +x14 <= 1.0 x14 >= -0.1 x14 >= 0.0 -x14 <= 1.0 -x14 <= 0.1 +x15 <= 0.1 +x15 <= 1.0 x15 >= -0.1 x15 >= 0.0 -x15 <= 1.0 -x15 <= 0.1 +x16 <= 0.1 +x16 <= 1.0 x16 >= -0.1 x16 >= 0.0 -x16 <= 1.0 -x16 <= 0.1 +x17 <= 0.1 +x17 <= 1.0 x17 >= -0.1 x17 >= 0.0 -x17 <= 1.0 -x17 <= 0.1 +x18 <= 0.1 +x18 <= 1.0 x18 >= -0.1 x18 >= 0.0 -x18 <= 1.0 -x18 <= 0.1 +x19 <= 0.1 +x19 <= 1.0 x19 >= -0.1 x19 >= 0.0 -x19 <= 1.0 -x19 <= 0.1 +x20 <= 0.1 +x20 <= 1.0 x20 >= -0.1 x20 >= 0.0 -x20 <= 1.0 -x20 <= 0.1 +x21 <= 0.1 +x21 <= 1.0 x21 >= -0.1 x21 >= 0.0 -x21 <= 1.0 -x21 <= 0.1 +x22 <= 0.1 +x22 <= 1.0 x22 >= -0.1 x22 >= 0.0 -x22 <= 1.0 -x22 <= 0.1 +x23 <= 0.1 +x23 <= 1.0 x23 >= -0.1 x23 >= 0.0 -x23 <= 1.0 -x23 <= 0.1 +x24 <= 0.1 +x24 <= 1.0 x24 >= -0.1 x24 >= 0.0 -x24 <= 1.0 -x24 <= 0.1 +x25 <= 0.1 +x25 <= 1.0 x25 >= -0.1 x25 >= 0.0 -x25 <= 1.0 -x25 <= 0.1 +x26 <= 0.1 +x26 <= 1.0 x26 >= -0.1 x26 >= 0.0 -x26 <= 1.0 -x26 <= 0.1 +x27 <= 0.1 +x27 <= 1.0 x27 >= -0.1 x27 >= 0.0 -x27 <= 1.0 -x27 <= 0.1 +x28 <= 0.1 +x28 <= 1.0 x28 >= -0.1 x28 >= 0.0 -x28 <= 1.0 -x28 <= 0.1 +x29 <= 0.1 +x29 <= 1.0 x29 >= -0.1 x29 >= 0.0 -x29 <= 1.0 -x29 <= 0.1 +x30 <= 0.1 +x30 <= 1.0 x30 >= -0.1 x30 >= 0.0 -x30 <= 1.0 -x30 <= 0.1 +x31 <= 0.1 +x31 <= 1.0 x31 >= -0.1 x31 >= 0.0 -x31 <= 1.0 -x31 <= 0.1 +x32 <= 0.1 +x32 <= 1.0 x32 >= -0.1 x32 >= 0.0 -x32 <= 1.0 -x32 <= 0.1 +x33 <= 0.1 +x33 <= 1.0 x33 >= -0.1 x33 >= 0.0 -x33 <= 1.0 -x33 <= 0.1 +x34 <= 0.1 +x34 <= 1.0 x34 >= -0.1 x34 >= 0.0 -x34 <= 1.0 -x34 <= 0.1 +x35 <= 0.1 +x35 <= 1.0 x35 >= -0.1 x35 >= 0.0 -x35 <= 1.0 -x35 <= 0.1 +x36 <= 0.1 +x36 <= 1.0 x36 >= -0.1 x36 >= 0.0 -x36 <= 1.0 -x36 <= 0.1 +x37 <= 0.1 +x37 <= 1.0 x37 >= -0.1 x37 >= 0.0 -x37 <= 1.0 -x37 <= 0.1 +x38 <= 0.1 +x38 <= 1.0 x38 >= -0.1 x38 >= 0.0 -x38 <= 1.0 -x38 <= 0.1 +x39 <= 0.1 +x39 <= 1.0 x39 >= -0.1 x39 >= 0.0 -x39 <= 1.0 -x39 <= 0.1 +x40 <= 0.1 +x40 <= 1.0 x40 >= -0.1 x40 >= 0.0 -x40 <= 1.0 -x40 <= 0.1 +x41 <= 0.1 +x41 <= 1.0 x41 >= -0.1 x41 >= 0.0 -x41 <= 1.0 -x41 <= 0.1 +x42 <= 0.1 +x42 <= 1.0 x42 >= -0.1 x42 >= 0.0 -x42 <= 1.0 -x42 <= 0.1 +x43 <= 0.1 +x43 <= 1.0 x43 >= -0.1 x43 >= 0.0 -x43 <= 1.0 -x43 <= 0.1 +x44 <= 0.1 +x44 <= 1.0 x44 >= -0.1 x44 >= 0.0 -x44 <= 1.0 -x44 <= 0.1 +x45 <= 0.1 +x45 <= 1.0 x45 >= -0.1 x45 >= 0.0 -x45 <= 1.0 -x45 <= 0.1 +x46 <= 0.1 +x46 <= 1.0 x46 >= -0.1 x46 >= 0.0 -x46 <= 1.0 -x46 <= 0.1 +x47 <= 0.1 +x47 <= 1.0 x47 >= -0.1 x47 >= 0.0 -x47 <= 1.0 -x47 <= 0.1 +x48 <= 0.1 +x48 <= 1.0 x48 >= -0.1 x48 >= 0.0 -x48 <= 1.0 -x48 <= 0.1 +x49 <= 0.1 +x49 <= 1.0 x49 >= -0.1 x49 >= 0.0 -x49 <= 1.0 -x49 <= 0.1 +x50 <= 0.1 +x50 <= 1.0 x50 >= -0.1 x50 >= 0.0 -x50 <= 1.0 -x50 <= 0.1 +x51 <= 0.1 +x51 <= 1.0 x51 >= -0.1 x51 >= 0.0 -x51 <= 1.0 -x51 <= 0.1 +x52 <= 0.1 +x52 <= 1.0 x52 >= -0.1 x52 >= 0.0 -x52 <= 1.0 -x52 <= 0.1 +x53 <= 0.1 +x53 <= 1.0 x53 >= -0.1 x53 >= 0.0 -x53 <= 1.0 -x53 <= 0.1 +x54 <= 0.1 +x54 <= 1.0 x54 >= -0.1 x54 >= 0.0 -x54 <= 1.0 -x54 <= 0.1 +x55 <= 0.1 +x55 <= 1.0 x55 >= -0.1 x55 >= 0.0 -x55 <= 1.0 -x55 <= 0.1 +x56 <= 0.1 +x56 <= 1.0 x56 >= -0.1 x56 >= 0.0 -x56 <= 1.0 -x56 <= 0.1 +x57 <= 0.1 +x57 <= 1.0 x57 >= -0.1 x57 >= 0.0 -x57 <= 1.0 -x57 <= 0.1 +x58 <= 0.1 +x58 <= 1.0 x58 >= -0.1 x58 >= 0.0 -x58 <= 1.0 -x58 <= 0.1 +x59 <= 0.1 +x59 <= 1.0 x59 >= -0.1 x59 >= 0.0 -x59 <= 1.0 -x59 <= 0.1 +x60 <= 0.1 +x60 <= 1.0 x60 >= -0.1 x60 >= 0.0 -x60 <= 1.0 -x60 <= 0.1 +x61 <= 0.1 +x61 <= 1.0 x61 >= -0.1 x61 >= 0.0 -x61 <= 1.0 -x61 <= 0.1 +x62 <= 0.1 +x62 <= 1.0 x62 >= -0.1 x62 >= 0.0 -x62 <= 1.0 -x62 <= 0.1 +x63 <= 0.1 +x63 <= 1.0 x63 >= -0.1 x63 >= 0.0 -x63 <= 1.0 -x63 <= 0.1 +x64 <= 0.1 +x64 <= 1.0 x64 >= -0.1 x64 >= 0.0 -x64 <= 1.0 -x64 <= 0.1 +x65 <= 0.1 +x65 <= 1.0 x65 >= -0.1 x65 >= 0.0 -x65 <= 1.0 -x65 <= 0.1 +x66 <= 0.1 +x66 <= 1.0 x66 >= -0.1 x66 >= 0.0 -x66 <= 1.0 -x66 <= 0.1 +x67 <= 0.1 +x67 <= 1.0 x67 >= -0.1 x67 >= 0.0 -x67 <= 1.0 -x67 <= 0.1 +x68 <= 0.1 +x68 <= 1.0 x68 >= -0.1 x68 >= 0.0 -x68 <= 1.0 -x68 <= 0.1 +x69 <= 0.1 +x69 <= 1.0 x69 >= -0.1 x69 >= 0.0 -x69 <= 1.0 -x69 <= 0.1 +x70 <= 0.1 +x70 <= 1.0 x70 >= -0.1 x70 >= 0.0 -x70 <= 1.0 -x70 <= 0.1 +x71 <= 0.1 +x71 <= 1.0 x71 >= -0.1 x71 >= 0.0 -x71 <= 1.0 -x71 <= 0.1 +x72 <= 0.1 +x72 <= 1.0 x72 >= -0.1 x72 >= 0.0 -x72 <= 1.0 -x72 <= 0.1 +x73 <= 0.1 +x73 <= 1.0 x73 >= -0.1 x73 >= 0.0 -x73 <= 1.0 -x73 <= 0.1 +x74 <= 0.1 +x74 <= 1.0 x74 >= -0.1 x74 >= 0.0 -x74 <= 1.0 -x74 <= 0.1 +x75 <= 0.1 +x75 <= 1.0 x75 >= -0.1 x75 >= 0.0 -x75 <= 1.0 -x75 <= 0.1 +x76 <= 0.1 +x76 <= 1.0 x76 >= -0.1 x76 >= 0.0 -x76 <= 1.0 -x76 <= 0.1 +x77 <= 0.1 +x77 <= 1.0 x77 >= -0.1 x77 >= 0.0 -x77 <= 1.0 -x77 <= 0.1 +x78 <= 0.1 +x78 <= 1.0 x78 >= -0.1 x78 >= 0.0 -x78 <= 1.0 -x78 <= 0.1 +x79 <= 0.1 +x79 <= 1.0 x79 >= -0.1 x79 >= 0.0 -x79 <= 1.0 -x79 <= 0.1 +x80 <= 0.1 +x80 <= 1.0 x80 >= -0.1 x80 >= 0.0 -x80 <= 1.0 -x80 <= 0.1 +x81 <= 0.1 +x81 <= 1.0 x81 >= -0.1 x81 >= 0.0 -x81 <= 1.0 -x81 <= 0.1 +x82 <= 0.1 +x82 <= 1.0 x82 >= -0.1 x82 >= 0.0 -x82 <= 1.0 -x82 <= 0.1 +x83 <= 0.1 +x83 <= 1.0 x83 >= -0.1 x83 >= 0.0 -x83 <= 1.0 -x83 <= 0.1 +x84 <= 0.1 +x84 <= 1.0 x84 >= -0.1 x84 >= 0.0 -x84 <= 1.0 -x84 <= 0.1 +x85 <= 0.1 +x85 <= 1.0 x85 >= -0.1 x85 >= 0.0 -x85 <= 1.0 -x85 <= 0.1 +x86 <= 0.1 +x86 <= 1.0 x86 >= -0.1 x86 >= 0.0 -x86 <= 1.0 -x86 <= 0.1 +x87 <= 0.1 +x87 <= 1.0 x87 >= -0.1 x87 >= 0.0 -x87 <= 1.0 -x87 <= 0.1 +x88 <= 0.1 +x88 <= 1.0 x88 >= -0.1 x88 >= 0.0 -x88 <= 1.0 -x88 <= 0.1 +x89 <= 0.1 +x89 <= 1.0 x89 >= -0.1 x89 >= 0.0 -x89 <= 1.0 -x89 <= 0.1 +x90 <= 0.1 +x90 <= 1.0 x90 >= -0.1 x90 >= 0.0 -x90 <= 1.0 -x90 <= 0.1 +x91 <= 0.1 +x91 <= 1.0 x91 >= -0.1 x91 >= 0.0 -x91 <= 1.0 -x91 <= 0.1 +x92 <= 0.1 +x92 <= 1.0 x92 >= -0.1 x92 >= 0.0 -x92 <= 1.0 -x92 <= 0.1 +x93 <= 0.1 +x93 <= 1.0 x93 >= -0.1 x93 >= 0.0 -x93 <= 1.0 -x93 <= 0.1 -x94 >= 0.0 -x94 >= 0.35490196078431374 -x94 <= 1.0 -x94 <= 0.5549019607843138 -x95 >= 0.0 -x95 >= 0.39019607843137255 -x95 <= 1.0 -x95 <= 0.5901960784313726 -x96 >= 0.0 -x96 >= 0.5705882352941176 -x96 <= 1.0 -x96 <= 0.7705882352941176 -x97 >= 0.0 -x97 >= 0.9 -x97 <= 1.1 -x97 <= 1.0 -x98 >= 0.0 -x98 >= 0.9 -x98 <= 1.1 -x98 <= 1.0 -x99 >= 0.0 -x99 >= 0.4882352941176471 -x99 <= 1.0 -x99 <= 0.6882352941176471 -x100 >= 0.0 -x100 >= 0.2647058823529412 -x100 <= 1.0 -x100 <= 0.46470588235294114 +x94 <= 0.1 +x94 <= 0.5450980392156863 +x94 >= -0.4549019607843137 +x94 >= -0.1 +x95 <= 0.1 +x95 <= 0.5098039215686274 +x95 >= -0.49019607843137253 +x95 >= -0.1 +x96 <= 0.1 +x96 <= 0.3294117647058824 +x96 >= -0.6705882352941176 +x96 >= -0.1 +x97 <= 0.0 +x97 <= 0.1 +x97 >= -1.0 +x97 >= -0.1 +x98 <= 0.0 +x98 <= 0.1 +x98 >= -1.0 +x98 >= -0.1 +x99 <= 0.1 +x99 <= 0.4117647058823529 +x99 >= -0.5882352941176471 +x99 >= -0.1 +x100 <= 0.1 +x100 <= 0.6352941176470588 +x100 >= -0.36470588235294116 +x100 >= -0.1 +x101 <= 0.1 +x101 <= 1.0 x101 >= -0.1 x101 >= 0.0 -x101 <= 1.0 -x101 <= 0.1 +x102 <= 0.1 +x102 <= 1.0 x102 >= -0.1 x102 >= 0.0 -x102 <= 1.0 -x102 <= 0.1 +x103 <= 0.1 +x103 <= 1.0 x103 >= -0.1 x103 >= 0.0 -x103 <= 1.0 -x103 <= 0.1 +x104 <= 0.1 +x104 <= 1.0 x104 >= -0.1 x104 >= 0.0 -x104 <= 1.0 -x104 <= 0.1 +x105 <= 0.1 +x105 <= 1.0 x105 >= -0.1 x105 >= 0.0 -x105 <= 1.0 -x105 <= 0.1 +x106 <= 0.1 +x106 <= 1.0 x106 >= -0.1 x106 >= 0.0 -x106 <= 1.0 -x106 <= 0.1 +x107 <= 0.1 +x107 <= 1.0 x107 >= -0.1 x107 >= 0.0 -x107 <= 1.0 -x107 <= 0.1 +x108 <= 0.1 +x108 <= 1.0 x108 >= -0.1 x108 >= 0.0 -x108 <= 1.0 -x108 <= 0.1 +x109 <= 0.1 +x109 <= 1.0 x109 >= -0.1 x109 >= 0.0 -x109 <= 1.0 -x109 <= 0.1 +x110 <= 0.1 +x110 <= 1.0 x110 >= -0.1 x110 >= 0.0 -x110 <= 1.0 -x110 <= 0.1 +x111 <= 0.1 +x111 <= 1.0 x111 >= -0.1 x111 >= 0.0 -x111 <= 1.0 -x111 <= 0.1 +x112 <= 0.1 +x112 <= 1.0 x112 >= -0.1 x112 >= 0.0 -x112 <= 1.0 -x112 <= 0.1 +x113 <= 0.1 +x113 <= 1.0 x113 >= -0.1 x113 >= 0.0 -x113 <= 1.0 -x113 <= 0.1 +x114 <= 0.1 +x114 <= 1.0 x114 >= -0.1 x114 >= 0.0 -x114 <= 1.0 -x114 <= 0.1 +x115 <= 0.1 +x115 <= 1.0 x115 >= -0.1 x115 >= 0.0 -x115 <= 1.0 -x115 <= 0.1 +x116 <= 0.1 +x116 <= 1.0 x116 >= -0.1 x116 >= 0.0 -x116 <= 1.0 -x116 <= 0.1 +x117 <= 0.1 +x117 <= 1.0 x117 >= -0.1 x117 >= 0.0 -x117 <= 1.0 -x117 <= 0.1 +x118 <= 0.1 +x118 <= 1.0 x118 >= -0.1 x118 >= 0.0 -x118 <= 1.0 -x118 <= 0.1 +x119 <= 0.1 +x119 <= 1.0 x119 >= -0.1 x119 >= 0.0 -x119 <= 1.0 -x119 <= 0.1 +x120 <= 0.1 +x120 <= 1.0 x120 >= -0.1 x120 >= 0.0 -x120 <= 1.0 -x120 <= 0.1 -x121 >= 0.0 -x121 >= 0.5627450980392157 -x121 <= 1.0 -x121 <= 0.7627450980392156 -x122 >= 0.0 -x122 >= 0.8921568627450981 -x122 <= 1.0921568627450982 -x122 <= 1.0 -x123 >= 0.0 -x123 >= 0.8921568627450981 -x123 <= 1.0921568627450982 -x123 <= 1.0 -x124 >= 0.0 -x124 >= 0.8921568627450981 -x124 <= 1.0921568627450982 -x124 <= 1.0 -x125 >= 0.0 -x125 >= 0.8921568627450981 -x125 <= 1.0921568627450982 -x125 <= 1.0 -x126 >= 0.0 -x126 >= 0.8921568627450981 -x126 <= 1.0921568627450982 -x126 <= 1.0 -x127 >= 0.0 -x127 >= 0.8921568627450981 -x127 <= 1.0921568627450982 -x127 <= 1.0 -x128 >= 0.0 -x128 >= 0.7549019607843137 -x128 <= 1.0 -x128 <= 0.9549019607843137 -x129 >= 0.0 -x129 >= 0.01764705882352941 -x129 <= 1.0 -x129 <= 0.21764705882352942 +x121 <= 0.1 +x121 <= 0.33725490196078434 +x121 >= -0.6627450980392157 +x121 >= -0.1 +x122 <= 0.007843137254901933 +x122 <= 0.1 +x122 >= -0.9921568627450981 +x122 >= -0.1 +x123 <= 0.007843137254901933 +x123 <= 0.1 +x123 >= -0.9921568627450981 +x123 >= -0.1 +x124 <= 0.007843137254901933 +x124 <= 0.1 +x124 >= -0.9921568627450981 +x124 >= -0.1 +x125 <= 0.007843137254901933 +x125 <= 0.1 +x125 >= -0.9921568627450981 +x125 >= -0.1 +x126 <= 0.007843137254901933 +x126 <= 0.1 +x126 >= -0.9921568627450981 +x126 >= -0.1 +x127 <= 0.007843137254901933 +x127 <= 0.1 +x127 >= -0.9921568627450981 +x127 >= -0.1 +x128 <= 0.1 +x128 <= 0.14509803921568631 +x128 >= -0.8549019607843137 +x128 >= -0.1 +x129 <= 0.1 +x129 <= 0.8823529411764706 +x129 >= -0.11764705882352941 +x129 >= -0.1 +x130 <= 0.1 +x130 <= 1.0 x130 >= -0.1 x130 >= 0.0 -x130 <= 1.0 -x130 <= 0.1 +x131 <= 0.1 +x131 <= 1.0 x131 >= -0.1 x131 >= 0.0 -x131 <= 1.0 -x131 <= 0.1 +x132 <= 0.1 +x132 <= 1.0 x132 >= -0.1 x132 >= 0.0 -x132 <= 1.0 -x132 <= 0.1 +x133 <= 0.1 +x133 <= 1.0 x133 >= -0.1 x133 >= 0.0 -x133 <= 1.0 -x133 <= 0.1 +x134 <= 0.1 +x134 <= 1.0 x134 >= -0.1 x134 >= 0.0 -x134 <= 1.0 -x134 <= 0.1 +x135 <= 0.1 +x135 <= 1.0 x135 >= -0.1 x135 >= 0.0 -x135 <= 1.0 -x135 <= 0.1 +x136 <= 0.1 +x136 <= 1.0 x136 >= -0.1 x136 >= 0.0 -x136 <= 1.0 -x136 <= 0.1 +x137 <= 0.1 +x137 <= 1.0 x137 >= -0.1 x137 >= 0.0 -x137 <= 1.0 -x137 <= 0.1 +x138 <= 0.1 +x138 <= 1.0 x138 >= -0.1 x138 >= 0.0 -x138 <= 1.0 -x138 <= 0.1 +x139 <= 0.1 +x139 <= 1.0 x139 >= -0.1 x139 >= 0.0 -x139 <= 1.0 -x139 <= 0.1 +x140 <= 0.1 +x140 <= 1.0 x140 >= -0.1 x140 >= 0.0 -x140 <= 1.0 -x140 <= 0.1 +x141 <= 0.1 +x141 <= 1.0 x141 >= -0.1 x141 >= 0.0 -x141 <= 1.0 -x141 <= 0.1 +x142 <= 0.1 +x142 <= 1.0 x142 >= -0.1 x142 >= 0.0 -x142 <= 1.0 -x142 <= 0.1 +x143 <= 0.1 +x143 <= 1.0 x143 >= -0.1 x143 >= 0.0 -x143 <= 1.0 -x143 <= 0.1 +x144 <= 0.1 +x144 <= 1.0 x144 >= -0.1 x144 >= 0.0 -x144 <= 1.0 -x144 <= 0.1 +x145 <= 0.1 +x145 <= 1.0 x145 >= -0.1 x145 >= 0.0 -x145 <= 1.0 -x145 <= 0.1 +x146 <= 0.1 +x146 <= 1.0 x146 >= -0.1 x146 >= 0.0 -x146 <= 1.0 -x146 <= 0.1 -x147 >= -0.1 -x147 >= 0.0 -x147 <= 1.0 -x147 <= 0.1 -x148 >= 0.0 -x148 >= 0.5627450980392157 -x148 <= 1.0 -x148 <= 0.7627450980392156 -x149 >= 0.0 -x149 >= 0.8921568627450981 -x149 <= 1.0921568627450982 -x149 <= 1.0 -x150 >= 0.0 -x150 >= 0.8921568627450981 -x150 <= 1.0921568627450982 -x150 <= 1.0 +x147 <= 0.2607843137254902 +x147 <= 1.1607843137254903 +x147 >= 0.06078431372549021 +x147 >= 0.1607843137254902 +x148 <= 0.5823529411764706 +x148 <= 0.8196078431372549 +x148 >= -0.18039215686274507 +x148 >= 0.3823529411764706 +x149 <= 0.49019607843137253 +x149 <= 0.5823529411764706 +x149 >= -0.5098039215686274 +x149 >= 0.3823529411764706 +x150 <= 0.6156862745098038 +x150 <= 0.7078431372549019 +x150 >= -0.38431372549019616 +x150 >= 0.5078431372549019 +x151 <= 1.0 +x151 <= 1.0921568627450982 x151 >= 0.0 x151 >= 0.8921568627450981 -x151 <= 1.0921568627450982 -x151 <= 1.0 -x152 >= 0.0 -x152 >= 0.7352941176470589 -x152 <= 1.0 -x152 <= 0.9352941176470588 -x153 >= 0.0 -x153 >= 0.45686274509803926 -x153 <= 1.0 -x153 <= 0.6568627450980392 -x154 >= 0.0 -x154 >= 0.5901960784313726 -x154 <= 1.0 -x154 <= 0.7901960784313725 -x155 >= 0.0 -x155 >= 0.8921568627450981 -x155 <= 1.0921568627450982 -x155 <= 1.0 -x156 >= 0.0 -x156 >= 0.8921568627450981 -x156 <= 1.0921568627450982 -x156 <= 1.0 -x157 >= 0.0 -x157 >= 0.37843137254901965 -x157 <= 1.0 -x157 <= 0.5784313725490197 -x158 >= -0.1 -x158 >= 0.0 -x158 <= 1.0 -x158 <= 0.1 +x152 <= 1.0921568627450982 +x152 <= 1.156862745098039 +x152 >= 0.1568627450980392 +x152 >= 0.8921568627450981 +x153 <= 1.0921568627450982 +x153 <= 1.4352941176470588 +x153 >= 0.43529411764705883 +x153 >= 0.8921568627450981 +x154 <= 0.7509803921568627 +x154 <= 0.9607843137254902 +x154 >= -0.039215686274509776 +x154 >= 0.5509803921568628 +x155 <= 0.49019607843137253 +x155 <= 0.5823529411764706 +x155 >= -0.5098039215686274 +x155 >= 0.3823529411764706 +x156 <= 0.49019607843137253 +x156 <= 0.5823529411764706 +x156 >= -0.5098039215686274 +x156 >= 0.3823529411764706 +x157 <= 0.5823529411764706 +x157 <= 1.003921568627451 +x157 >= 0.0039215686274509665 +x157 >= 0.3823529411764706 +x158 <= 0.5627450980392157 +x158 <= 1.4627450980392158 +x158 >= 0.36274509803921573 +x158 >= 0.4627450980392157 +x159 <= 0.1 +x159 <= 1.0 x159 >= -0.1 x159 >= 0.0 -x159 <= 1.0 -x159 <= 0.1 +x160 <= 0.1 +x160 <= 1.0 x160 >= -0.1 x160 >= 0.0 -x160 <= 1.0 -x160 <= 0.1 +x161 <= 0.1 +x161 <= 1.0 x161 >= -0.1 x161 >= 0.0 -x161 <= 1.0 -x161 <= 0.1 +x162 <= 0.1 +x162 <= 1.0 x162 >= -0.1 x162 >= 0.0 -x162 <= 1.0 -x162 <= 0.1 +x163 <= 0.1 +x163 <= 1.0 x163 >= -0.1 x163 >= 0.0 -x163 <= 1.0 -x163 <= 0.1 +x164 <= 0.1 +x164 <= 1.0 x164 >= -0.1 x164 >= 0.0 -x164 <= 1.0 -x164 <= 0.1 +x165 <= 0.1 +x165 <= 1.0 x165 >= -0.1 x165 >= 0.0 -x165 <= 1.0 -x165 <= 0.1 +x166 <= 0.1 +x166 <= 1.0 x166 >= -0.1 x166 >= 0.0 -x166 <= 1.0 -x166 <= 0.1 +x167 <= 0.1 +x167 <= 1.0 x167 >= -0.1 x167 >= 0.0 -x167 <= 1.0 -x167 <= 0.1 +x168 <= 0.1 +x168 <= 1.0 x168 >= -0.1 x168 >= 0.0 -x168 <= 1.0 -x168 <= 0.1 -x169 >= -0.1 -x169 >= 0.0 -x169 <= 1.0 -x169 <= 0.1 -x170 >= -0.1 -x170 >= 0.0 -x170 <= 1.0 -x170 <= 0.1 -x171 >= -0.1 -x171 >= 0.0 -x171 <= 1.0 -x171 <= 0.1 -x172 >= -0.1 -x172 >= 0.0 -x172 <= 1.0 -x172 <= 0.1 -x173 >= -0.1 -x173 >= 0.0 -x173 <= 1.0 -x173 <= 0.1 -x174 >= -0.1 -x174 >= 0.0 -x174 <= 1.0 -x174 <= 0.1 -x175 >= 0.0 -x175 >= 0.10392156862745097 -x175 <= 1.0 -x175 <= 0.30392156862745096 -x176 >= 0.0 -x176 >= 0.8803921568627451 -x176 <= 1.080392156862745 -x176 <= 1.0 +x169 <= 0.3235294117647059 +x169 <= 1.223529411764706 +x169 >= 0.12352941176470589 +x169 >= 0.2235294117647059 +x170 <= 0.5588235294117647 +x170 <= 1.4588235294117646 +x170 >= 0.3588235294117647 +x170 >= 0.4588235294117647 +x171 <= 0.5588235294117647 +x171 <= 1.4588235294117646 +x171 >= 0.3588235294117647 +x171 >= 0.4588235294117647 +x172 <= 0.7627450980392156 +x172 <= 1.6627450980392156 +x172 >= 0.5627450980392157 +x172 >= 0.6627450980392157 +x173 <= 1.0686274509803921 +x173 <= 1.9686274509803923 +x173 >= 0.8686274509803922 +x173 >= 0.9686274509803922 +x174 <= 1.0686274509803921 +x174 <= 1.9686274509803923 +x174 >= 0.8686274509803922 +x174 >= 0.9686274509803922 +x175 <= 1.076470588235294 +x175 <= 1.772549019607843 +x175 >= 0.7725490196078431 +x175 >= 0.8764705882352941 +x176 <= 1.011764705882353 +x176 <= 1.0921568627450982 +x176 >= 0.01176470588235301 +x176 >= 0.8921568627450981 +x177 <= 1.0 +x177 <= 1.0921568627450982 x177 >= 0.0 x177 >= 0.8921568627450981 -x177 <= 1.0921568627450982 -x177 <= 1.0 -x178 >= 0.0 -x178 >= 0.7235294117647059 -x178 <= 1.0 -x178 <= 0.9235294117647058 -x179 >= 0.0 -x179 >= 0.025490196078431372 -x179 <= 1.0 -x179 <= 0.22549019607843138 -x180 >= -0.052941176470588235 -x180 >= 0.0 -x180 <= 1.0 -x180 <= 0.14705882352941177 -x181 >= -0.1 -x181 >= 0.0 -x181 <= 1.0 -x181 <= 0.1 -x182 >= -0.07647058823529412 -x182 >= 0.0 -x182 <= 1.0 -x182 <= 0.12352941176470589 -x183 >= 0.0 -x183 >= 0.707843137254902 -x183 <= 1.0 -x183 <= 0.907843137254902 +x178 <= 1.0921568627450982 +x178 <= 1.1686274509803922 +x178 >= 0.16862745098039222 +x178 >= 0.8921568627450981 +x179 <= 1.0921568627450982 +x179 <= 1.8666666666666667 +x179 >= 0.8666666666666667 +x179 >= 0.8921568627450981 +x180 <= 1.0921568627450982 +x180 <= 1.9450980392156862 +x180 >= 0.8921568627450981 +x180 >= 0.9450980392156862 +x181 <= 1.0921568627450982 +x181 <= 1.992156862745098 +x181 >= 0.8921568627450981 +x181 >= 0.9921568627450981 +x182 <= 1.0921568627450982 +x182 <= 1.9686274509803923 +x182 >= 0.8921568627450981 +x182 >= 0.9686274509803922 +x183 <= 1.0921568627450982 +x183 <= 1.184313725490196 +x183 >= 0.1843137254901961 +x183 >= 0.8921568627450981 +x184 <= 1.0 +x184 <= 1.0921568627450982 x184 >= 0.0 x184 >= 0.8921568627450981 -x184 <= 1.0921568627450982 -x184 <= 1.0 -x185 >= 0.0 -x185 >= 0.4490196078431373 -x185 <= 1.0 -x185 <= 0.6490196078431373 -x186 >= -0.1 -x186 >= 0.0 -x186 <= 1.0 -x186 <= 0.1 -x187 >= -0.1 -x187 >= 0.0 -x187 <= 1.0 -x187 <= 0.1 +x185 <= 1.0921568627450982 +x185 <= 1.4431372549019608 +x185 >= 0.44313725490196076 +x185 >= 0.8921568627450981 +x186 <= 1.0921568627450982 +x186 <= 1.992156862745098 +x186 >= 0.8921568627450981 +x186 >= 0.9921568627450981 +x187 <= 0.7823529411764706 +x187 <= 1.6823529411764706 +x187 >= 0.5823529411764706 +x187 >= 0.6823529411764706 +x188 <= 0.1 +x188 <= 1.0 x188 >= -0.1 x188 >= 0.0 -x188 <= 1.0 -x188 <= 0.1 +x189 <= 0.1 +x189 <= 1.0 x189 >= -0.1 x189 >= 0.0 -x189 <= 1.0 -x189 <= 0.1 +x190 <= 0.1 +x190 <= 1.0 x190 >= -0.1 x190 >= 0.0 -x190 <= 1.0 -x190 <= 0.1 +x191 <= 0.1 +x191 <= 1.0 x191 >= -0.1 x191 >= 0.0 -x191 <= 1.0 -x191 <= 0.1 +x192 <= 0.1 +x192 <= 1.0 x192 >= -0.1 x192 >= 0.0 -x192 <= 1.0 -x192 <= 0.1 +x193 <= 0.1 +x193 <= 1.0 x193 >= -0.1 x193 >= 0.0 -x193 <= 1.0 -x193 <= 0.1 +x194 <= 0.1 +x194 <= 1.0 x194 >= -0.1 x194 >= 0.0 -x194 <= 1.0 -x194 <= 0.1 +x195 <= 0.1 +x195 <= 1.0 x195 >= -0.1 x195 >= 0.0 -x195 <= 1.0 -x195 <= 0.1 +x196 <= 0.1 +x196 <= 1.0 x196 >= -0.1 x196 >= 0.0 -x196 <= 1.0 -x196 <= 0.1 -x197 >= -0.1 -x197 >= 0.0 -x197 <= 1.0 -x197 <= 0.1 -x198 >= -0.1 -x198 >= 0.0 -x198 <= 1.0 -x198 <= 0.1 -x199 >= -0.1 -x199 >= 0.0 -x199 <= 1.0 -x199 <= 0.1 -x200 >= -0.1 -x200 >= 0.0 -x200 <= 1.0 -x200 <= 0.1 -x201 >= -0.1 -x201 >= 0.0 -x201 <= 1.0 -x201 <= 0.1 -x202 >= -0.1 -x202 >= 0.0 -x202 <= 1.0 -x202 <= 0.1 -x203 >= 0.0 -x203 >= 0.20196078431372547 -x203 <= 1.0 -x203 <= 0.40196078431372545 -x204 >= 0.0 -x204 >= 0.884313725490196 -x204 <= 1.084313725490196 -x204 <= 1.0 -x205 >= 0.0 -x205 >= 0.7235294117647059 -x205 <= 1.0 -x205 <= 0.9235294117647058 -x206 >= -0.0019607843137254915 -x206 >= 0.0 -x206 <= 1.0 -x206 <= 0.1980392156862745 -x207 >= -0.1 -x207 >= 0.0 -x207 <= 1.0 -x207 <= 0.1 -x208 >= -0.1 -x208 >= 0.0 -x208 <= 1.0 -x208 <= 0.1 -x209 >= -0.1 -x209 >= 0.0 -x209 <= 1.0 -x209 <= 0.1 -x210 >= 0.0 -x210 >= 0.37843137254901965 -x210 <= 1.0 -x210 <= 0.5784313725490197 -x211 >= 0.0 -x211 >= 0.8725490196078431 -x211 <= 1.072549019607843 -x211 <= 1.0 +x197 <= 0.5823529411764706 +x197 <= 1.4823529411764707 +x197 >= 0.3823529411764706 +x197 >= 0.4823529411764706 +x198 <= 1.0921568627450982 +x198 <= 1.992156862745098 +x198 >= 0.8921568627450981 +x198 >= 0.9921568627450981 +x199 <= 1.0921568627450982 +x199 <= 1.992156862745098 +x199 >= 0.8921568627450981 +x199 >= 0.9921568627450981 +x200 <= 1.0921568627450982 +x200 <= 1.992156862745098 +x200 >= 0.8921568627450981 +x200 >= 0.9921568627450981 +x201 <= 1.0921568627450982 +x201 <= 1.992156862745098 +x201 >= 0.8921568627450981 +x201 >= 0.9921568627450981 +x202 <= 1.0921568627450982 +x202 <= 1.992156862745098 +x202 >= 0.8921568627450981 +x202 >= 0.9921568627450981 +x203 <= 1.0921568627450982 +x203 <= 1.6901960784313725 +x203 >= 0.6901960784313725 +x203 >= 0.8921568627450981 +x204 <= 1.007843137254902 +x204 <= 1.0921568627450982 +x204 >= 0.007843137254902044 +x204 >= 0.8921568627450981 +x205 <= 0.7509803921568627 +x205 <= 0.8274509803921569 +x205 >= -0.17254901960784308 +x205 >= 0.5509803921568628 +x206 <= 0.6607843137254902 +x206 <= 1.4627450980392156 +x206 >= 0.4607843137254902 +x206 >= 0.4627450980392157 +x207 <= 0.7588235294117647 +x207 <= 1.6588235294117646 +x207 >= 0.5588235294117647 +x207 >= 0.6588235294117647 +x208 <= 1.0921568627450982 +x208 <= 1.992156862745098 +x208 >= 0.8921568627450981 +x208 >= 0.9921568627450981 +x209 <= 1.0921568627450982 +x209 <= 1.992156862745098 +x209 >= 0.8921568627450981 +x209 >= 0.9921568627450981 +x210 <= 1.0921568627450982 +x210 <= 1.5137254901960784 +x210 >= 0.5137254901960784 +x210 >= 0.8921568627450981 +x211 <= 1.0196078431372548 +x211 <= 1.0921568627450982 +x211 >= 0.019607843137254943 +x211 >= 0.8921568627450981 +x212 <= 1.0 +x212 <= 1.0921568627450982 x212 >= 0.0 x212 >= 0.8921568627450981 -x212 <= 1.0921568627450982 -x212 <= 1.0 -x213 >= 0.0 -x213 >= 0.1549019607843137 -x213 <= 1.0 -x213 <= 0.3549019607843137 -x214 >= -0.1 -x214 >= 0.0 -x214 <= 1.0 -x214 <= 0.1 -x215 >= -0.1 -x215 >= 0.0 -x215 <= 1.0 -x215 <= 0.1 +x213 <= 1.0921568627450982 +x213 <= 1.7372549019607844 +x213 >= 0.7372549019607844 +x213 >= 0.8921568627450981 +x214 <= 1.0921568627450982 +x214 <= 1.992156862745098 +x214 >= 0.8921568627450981 +x214 >= 0.9921568627450981 +x215 <= 1.072549019607843 +x215 <= 1.9725490196078432 +x215 >= 0.8725490196078431 +x215 >= 0.9725490196078431 +x216 <= 0.1 +x216 <= 1.0 x216 >= -0.1 x216 >= 0.0 -x216 <= 1.0 -x216 <= 0.1 +x217 <= 0.1 +x217 <= 1.0 x217 >= -0.1 x217 >= 0.0 -x217 <= 1.0 -x217 <= 0.1 +x218 <= 0.1 +x218 <= 1.0 x218 >= -0.1 x218 >= 0.0 -x218 <= 1.0 -x218 <= 0.1 +x219 <= 0.1 +x219 <= 1.0 x219 >= -0.1 x219 >= 0.0 -x219 <= 1.0 -x219 <= 0.1 +x220 <= 0.1 +x220 <= 1.0 x220 >= -0.1 x220 >= 0.0 -x220 <= 1.0 -x220 <= 0.1 +x221 <= 0.1 +x221 <= 1.0 x221 >= -0.1 x221 >= 0.0 -x221 <= 1.0 -x221 <= 0.1 +x222 <= 0.1 +x222 <= 1.0 x222 >= -0.1 x222 >= 0.0 -x222 <= 1.0 -x222 <= 0.1 +x223 <= 0.1 +x223 <= 1.0 x223 >= -0.1 x223 >= 0.0 -x223 <= 1.0 -x223 <= 0.1 +x224 <= 0.1 +x224 <= 1.0 x224 >= -0.1 x224 >= 0.0 -x224 <= 1.0 -x224 <= 0.1 -x225 >= -0.1 -x225 >= 0.0 -x225 <= 1.0 -x225 <= 0.1 -x226 >= -0.1 -x226 >= 0.0 -x226 <= 1.0 -x226 <= 0.1 -x227 >= -0.1 -x227 >= 0.0 -x227 <= 1.0 -x227 <= 0.1 -x228 >= -0.1 -x228 >= 0.0 -x228 <= 1.0 -x228 <= 0.1 -x229 >= -0.1 -x229 >= 0.0 -x229 <= 1.0 -x229 <= 0.1 -x230 >= -0.1 -x230 >= 0.0 -x230 <= 1.0 -x230 <= 0.1 -x231 >= -0.1 -x231 >= 0.0 -x231 <= 1.0 -x231 <= 0.1 -x232 >= 0.0 -x232 >= 0.021568627450980392 -x232 <= 1.0 -x232 <= 0.22156862745098038 -x233 >= -0.029411764705882353 -x233 >= 0.0 -x233 <= 1.0 -x233 <= 0.17058823529411765 +x225 <= 0.1392156862745098 +x225 <= 1.0392156862745099 +x225 >= -0.060784313725490195 +x225 >= 0.0392156862745098 +x226 <= 0.676470588235294 +x226 <= 1.576470588235294 +x226 >= 0.4764705882352941 +x226 >= 0.5764705882352941 +x227 <= 0.6882352941176471 +x227 <= 1.5882352941176472 +x227 >= 0.4882352941176471 +x227 >= 0.5882352941176471 +x228 <= 0.6882352941176471 +x228 <= 1.5882352941176472 +x228 >= 0.4882352941176471 +x228 >= 0.5882352941176471 +x229 <= 0.6882352941176471 +x229 <= 1.5882352941176472 +x229 >= 0.4882352941176471 +x229 >= 0.5882352941176471 +x230 <= 0.2450980392156863 +x230 <= 1.1450980392156862 +x230 >= 0.04509803921568629 +x230 >= 0.1450980392156863 +x231 <= 0.1784313725490196 +x231 <= 1.0784313725490196 +x231 >= -0.021568627450980392 +x231 >= 0.0784313725490196 +x232 <= 0.1784313725490196 +x232 <= 0.9568627450980393 +x232 >= -0.043137254901960784 +x232 >= -0.021568627450980392 +x233 <= 0.11960784313725491 +x233 <= 0.9490196078431372 +x233 >= -0.0803921568627451 +x233 >= -0.050980392156862744 +x234 <= 0.1 +x234 <= 1.0 x234 >= -0.1 x234 >= 0.0 -x234 <= 1.0 -x234 <= 0.1 -x235 >= -0.1 -x235 >= 0.0 -x235 <= 1.0 -x235 <= 0.1 -x236 >= -0.1 -x236 >= 0.0 -x236 <= 1.0 -x236 <= 0.1 -x237 >= -0.1 -x237 >= 0.0 -x237 <= 1.0 -x237 <= 0.1 -x238 >= 0.0 -x238 >= 0.7196078431372549 -x238 <= 1.0 -x238 <= 0.9196078431372549 -x239 >= 0.0 -x239 >= 0.8921568627450981 -x239 <= 1.0921568627450982 -x239 <= 1.0 -x240 >= 0.0 -x240 >= 0.8921568627450981 -x240 <= 1.0921568627450982 -x240 <= 1.0 -x241 >= 0.0 -x241 >= 0.1549019607843137 -x241 <= 1.0 -x241 <= 0.3549019607843137 -x242 >= -0.1 -x242 >= 0.0 -x242 <= 1.0 -x242 <= 0.1 -x243 >= -0.1 -x243 >= 0.0 -x243 <= 1.0 -x243 <= 0.1 +x235 <= 0.11960784313725491 +x235 <= 1.0196078431372548 +x235 >= -0.0803921568627451 +x235 >= 0.0196078431372549 +x236 <= 0.1784313725490196 +x236 <= 1.0784313725490196 +x236 >= -0.021568627450980392 +x236 >= 0.0784313725490196 +x237 <= 0.1784313725490196 +x237 <= 1.0784313725490196 +x237 >= -0.021568627450980392 +x237 >= 0.0784313725490196 +x238 <= 0.1784313725490196 +x238 <= 0.25882352941176473 +x238 >= -0.7411764705882353 +x238 >= -0.021568627450980392 +x239 <= 0.08627450980392154 +x239 <= 0.1784313725490196 +x239 >= -0.9137254901960785 +x239 >= -0.021568627450980392 +x240 <= 0.1764705882352941 +x240 <= 0.26862745098039215 +x240 >= -0.8235294117647058 +x240 >= 0.06862745098039216 +x241 <= 1.0921568627450982 +x241 <= 1.7372549019607844 +x241 >= 0.7372549019607844 +x241 >= 0.8921568627450981 +x242 <= 1.0921568627450982 +x242 <= 1.992156862745098 +x242 >= 0.8921568627450981 +x242 >= 0.9921568627450981 +x243 <= 1.072549019607843 +x243 <= 1.9725490196078432 +x243 >= 0.8725490196078431 +x243 >= 0.9725490196078431 +x244 <= 0.1 +x244 <= 1.0 x244 >= -0.1 x244 >= 0.0 -x244 <= 1.0 -x244 <= 0.1 +x245 <= 0.1 +x245 <= 1.0 x245 >= -0.1 x245 >= 0.0 -x245 <= 1.0 -x245 <= 0.1 +x246 <= 0.1 +x246 <= 1.0 x246 >= -0.1 x246 >= 0.0 -x246 <= 1.0 -x246 <= 0.1 +x247 <= 0.1 +x247 <= 1.0 x247 >= -0.1 x247 >= 0.0 -x247 <= 1.0 -x247 <= 0.1 +x248 <= 0.1 +x248 <= 1.0 x248 >= -0.1 x248 >= 0.0 -x248 <= 1.0 -x248 <= 0.1 +x249 <= 0.1 +x249 <= 1.0 x249 >= -0.1 x249 >= 0.0 -x249 <= 1.0 -x249 <= 0.1 +x250 <= 0.1 +x250 <= 1.0 x250 >= -0.1 x250 >= 0.0 -x250 <= 1.0 -x250 <= 0.1 +x251 <= 0.1 +x251 <= 1.0 x251 >= -0.1 x251 >= 0.0 -x251 <= 1.0 -x251 <= 0.1 +x252 <= 0.1 +x252 <= 1.0 x252 >= -0.1 x252 >= 0.0 -x252 <= 1.0 -x252 <= 0.1 +x253 <= 0.1 +x253 <= 1.0 x253 >= -0.1 x253 >= 0.0 -x253 <= 1.0 -x253 <= 0.1 +x254 <= 0.1 +x254 <= 1.0 x254 >= -0.1 x254 >= 0.0 -x254 <= 1.0 -x254 <= 0.1 +x255 <= 0.1 +x255 <= 1.0 x255 >= -0.1 x255 >= 0.0 -x255 <= 1.0 -x255 <= 0.1 +x256 <= 0.1 +x256 <= 1.0 x256 >= -0.1 x256 >= 0.0 -x256 <= 1.0 -x256 <= 0.1 +x257 <= 0.1 +x257 <= 1.0 x257 >= -0.1 x257 >= 0.0 -x257 <= 1.0 -x257 <= 0.1 +x258 <= 0.1 +x258 <= 1.0 x258 >= -0.1 x258 >= 0.0 -x258 <= 1.0 -x258 <= 0.1 +x259 <= 0.1 +x259 <= 1.0 x259 >= -0.1 x259 >= 0.0 -x259 <= 1.0 -x259 <= 0.1 +x260 <= 0.1 +x260 <= 1.0 x260 >= -0.1 x260 >= 0.0 -x260 <= 1.0 -x260 <= 0.1 +x261 <= 0.1 +x261 <= 1.0 x261 >= -0.1 x261 >= 0.0 -x261 <= 1.0 -x261 <= 0.1 +x262 <= 0.1 +x262 <= 1.0 x262 >= -0.1 x262 >= 0.0 -x262 <= 1.0 -x262 <= 0.1 +x263 <= 0.1 +x263 <= 1.0 x263 >= -0.1 x263 >= 0.0 -x263 <= 1.0 -x263 <= 0.1 +x264 <= 0.1 +x264 <= 1.0 x264 >= -0.1 x264 >= 0.0 -x264 <= 1.0 -x264 <= 0.1 -x265 >= 0.0 -x265 >= 0.3588235294117647 -x265 <= 1.0 -x265 <= 0.5588235294117647 -x266 >= 0.0 -x266 >= 0.8686274509803922 -x266 <= 1.0686274509803921 -x266 <= 1.0 -x267 >= 0.0 -x267 >= 0.8921568627450981 -x267 <= 1.0921568627450982 -x267 <= 1.0 -x268 >= 0.0 -x268 >= 0.6764705882352942 -x268 <= 1.0 -x268 <= 0.8764705882352941 -x269 >= -0.060784313725490195 -x269 >= 0.0 -x269 <= 1.0 -x269 <= 0.1392156862745098 -x270 >= -0.1 -x270 >= 0.0 -x270 <= 1.0 -x270 <= 0.1 -x271 >= -0.1 -x271 >= 0.0 -x271 <= 1.0 -x271 <= 0.1 +x265 <= 0.1 +x265 <= 0.5411764705882354 +x265 >= -0.4588235294117647 +x265 >= -0.1 +x266 <= 0.03137254901960784 +x266 <= 0.1 +x266 >= -0.9686274509803922 +x266 >= -0.1 +x267 <= 0.007843137254901933 +x267 <= 0.1 +x267 >= -0.9921568627450981 +x267 >= -0.1 +x268 <= 0.1980392156862745 +x268 <= 0.32156862745098036 +x268 >= -0.6784313725490196 +x268 >= -0.0019607843137254915 +x269 <= 1.0921568627450982 +x269 <= 1.9529411764705882 +x269 >= 0.8921568627450981 +x269 >= 0.9529411764705883 +x270 <= 1.0921568627450982 +x270 <= 1.992156862745098 +x270 >= 0.8921568627450981 +x270 >= 0.9921568627450981 +x271 <= 1.072549019607843 +x271 <= 1.9725490196078432 +x271 >= 0.8725490196078431 +x271 >= 0.9725490196078431 +x272 <= 0.1 +x272 <= 1.0 x272 >= -0.1 x272 >= 0.0 -x272 <= 1.0 -x272 <= 0.1 +x273 <= 0.1 +x273 <= 1.0 x273 >= -0.1 x273 >= 0.0 -x273 <= 1.0 -x273 <= 0.1 +x274 <= 0.1 +x274 <= 1.0 x274 >= -0.1 x274 >= 0.0 -x274 <= 1.0 -x274 <= 0.1 +x275 <= 0.1 +x275 <= 1.0 x275 >= -0.1 x275 >= 0.0 -x275 <= 1.0 -x275 <= 0.1 +x276 <= 0.1 +x276 <= 1.0 x276 >= -0.1 x276 >= 0.0 -x276 <= 1.0 -x276 <= 0.1 +x277 <= 0.1 +x277 <= 1.0 x277 >= -0.1 x277 >= 0.0 -x277 <= 1.0 -x277 <= 0.1 +x278 <= 0.1 +x278 <= 1.0 x278 >= -0.1 x278 >= 0.0 -x278 <= 1.0 -x278 <= 0.1 +x279 <= 0.1 +x279 <= 1.0 x279 >= -0.1 x279 >= 0.0 -x279 <= 1.0 -x279 <= 0.1 +x280 <= 0.1 +x280 <= 1.0 x280 >= -0.1 x280 >= 0.0 -x280 <= 1.0 -x280 <= 0.1 +x281 <= 0.1 +x281 <= 1.0 x281 >= -0.1 x281 >= 0.0 -x281 <= 1.0 -x281 <= 0.1 +x282 <= 0.1 +x282 <= 1.0 x282 >= -0.1 x282 >= 0.0 -x282 <= 1.0 -x282 <= 0.1 +x283 <= 0.1 +x283 <= 1.0 x283 >= -0.1 x283 >= 0.0 -x283 <= 1.0 -x283 <= 0.1 +x284 <= 0.1 +x284 <= 1.0 x284 >= -0.1 x284 >= 0.0 -x284 <= 1.0 -x284 <= 0.1 +x285 <= 0.1 +x285 <= 1.0 x285 >= -0.1 x285 >= 0.0 -x285 <= 1.0 -x285 <= 0.1 +x286 <= 0.1 +x286 <= 1.0 x286 >= -0.1 x286 >= 0.0 -x286 <= 1.0 -x286 <= 0.1 +x287 <= 0.1 +x287 <= 1.0 x287 >= -0.1 x287 >= 0.0 -x287 <= 1.0 -x287 <= 0.1 +x288 <= 0.1 +x288 <= 1.0 x288 >= -0.1 x288 >= 0.0 -x288 <= 1.0 -x288 <= 0.1 +x289 <= 0.1 +x289 <= 1.0 x289 >= -0.1 x289 >= 0.0 -x289 <= 1.0 -x289 <= 0.1 +x290 <= 0.1 +x290 <= 1.0 x290 >= -0.1 x290 >= 0.0 -x290 <= 1.0 -x290 <= 0.1 +x291 <= 0.1 +x291 <= 1.0 x291 >= -0.1 x291 >= 0.0 -x291 <= 1.0 -x291 <= 0.1 -x292 >= 0.0 -x292 >= 0.1980392156862745 -x292 <= 1.0 -x292 <= 0.3980392156862745 -x293 >= 0.0 -x293 >= 0.8686274509803922 -x293 <= 1.0686274509803921 -x293 <= 1.0 -x294 >= 0.0 -x294 >= 0.8921568627450981 -x294 <= 1.0921568627450982 -x294 <= 1.0 -x295 >= 0.0 -x295 >= 0.8058823529411765 -x295 <= 1.0058823529411764 -x295 <= 1.0 -x296 >= 0.0 -x296 >= 0.14705882352941177 -x296 <= 1.0 -x296 <= 0.34705882352941175 -x297 >= -0.1 -x297 >= 0.0 -x297 <= 1.0 -x297 <= 0.1 -x298 >= -0.1 -x298 >= 0.0 -x298 <= 1.0 -x298 <= 0.1 -x299 >= -0.1 -x299 >= 0.0 -x299 <= 1.0 -x299 <= 0.1 +x292 <= 0.1 +x292 <= 0.7019607843137254 +x292 >= -0.2980392156862745 +x292 >= -0.1 +x293 <= 0.03137254901960784 +x293 <= 0.1 +x293 >= -0.9686274509803922 +x293 >= -0.1 +x294 <= 0.007843137254901933 +x294 <= 0.1 +x294 >= -0.9921568627450981 +x294 >= -0.1 +x295 <= 0.1411764705882353 +x295 <= 0.14705882352941177 +x295 >= -0.8588235294117648 +x295 >= -0.052941176470588235 +x296 <= 0.7784313725490196 +x296 <= 1.4313725490196079 +x296 >= 0.43137254901960786 +x296 >= 0.5784313725490197 +x297 <= 1.0921568627450982 +x297 <= 1.992156862745098 +x297 >= 0.8921568627450981 +x297 >= 0.9921568627450981 +x298 <= 1.0921568627450982 +x298 <= 1.992156862745098 +x298 >= 0.8921568627450981 +x298 >= 0.9921568627450981 +x299 <= 0.6254901960784314 +x299 <= 1.5254901960784313 +x299 >= 0.4254901960784314 +x299 >= 0.5254901960784314 +x300 <= 0.1 +x300 <= 1.0 x300 >= -0.1 x300 >= 0.0 -x300 <= 1.0 -x300 <= 0.1 +x301 <= 0.1 +x301 <= 1.0 x301 >= -0.1 x301 >= 0.0 -x301 <= 1.0 -x301 <= 0.1 +x302 <= 0.1 +x302 <= 1.0 x302 >= -0.1 x302 >= 0.0 -x302 <= 1.0 -x302 <= 0.1 +x303 <= 0.1 +x303 <= 1.0 x303 >= -0.1 x303 >= 0.0 -x303 <= 1.0 -x303 <= 0.1 +x304 <= 0.1 +x304 <= 1.0 x304 >= -0.1 x304 >= 0.0 -x304 <= 1.0 -x304 <= 0.1 +x305 <= 0.1 +x305 <= 1.0 x305 >= -0.1 x305 >= 0.0 -x305 <= 1.0 -x305 <= 0.1 +x306 <= 0.1 +x306 <= 1.0 x306 >= -0.1 x306 >= 0.0 -x306 <= 1.0 -x306 <= 0.1 +x307 <= 0.1 +x307 <= 1.0 x307 >= -0.1 x307 >= 0.0 -x307 <= 1.0 -x307 <= 0.1 +x308 <= 0.1 +x308 <= 1.0 x308 >= -0.1 x308 >= 0.0 -x308 <= 1.0 -x308 <= 0.1 +x309 <= 0.1 +x309 <= 1.0 x309 >= -0.1 x309 >= 0.0 -x309 <= 1.0 -x309 <= 0.1 +x310 <= 0.1 +x310 <= 1.0 x310 >= -0.1 x310 >= 0.0 -x310 <= 1.0 -x310 <= 0.1 +x311 <= 0.1 +x311 <= 1.0 x311 >= -0.1 x311 >= 0.0 -x311 <= 1.0 -x311 <= 0.1 +x312 <= 0.1 +x312 <= 1.0 x312 >= -0.1 x312 >= 0.0 -x312 <= 1.0 -x312 <= 0.1 +x313 <= 0.1 +x313 <= 1.0 x313 >= -0.1 x313 >= 0.0 -x313 <= 1.0 -x313 <= 0.1 +x314 <= 0.1 +x314 <= 1.0 x314 >= -0.1 x314 >= 0.0 -x314 <= 1.0 -x314 <= 0.1 +x315 <= 0.1 +x315 <= 1.0 x315 >= -0.1 x315 >= 0.0 -x315 <= 1.0 -x315 <= 0.1 +x316 <= 0.1 +x316 <= 1.0 x316 >= -0.1 x316 >= 0.0 -x316 <= 1.0 -x316 <= 0.1 +x317 <= 0.1 +x317 <= 1.0 x317 >= -0.1 x317 >= 0.0 -x317 <= 1.0 -x317 <= 0.1 +x318 <= 0.1 +x318 <= 1.0 x318 >= -0.1 x318 >= 0.0 -x318 <= 1.0 -x318 <= 0.1 +x319 <= 0.1 +x319 <= 1.0 x319 >= -0.1 x319 >= 0.0 -x319 <= 1.0 -x319 <= 0.1 -x320 >= 0.0 -x320 >= 0.4019607843137255 -x320 <= 1.0 -x320 <= 0.6019607843137255 -x321 >= 0.0 -x321 >= 0.8921568627450981 -x321 <= 1.0921568627450982 -x321 <= 1.0 -x322 >= 0.0 -x322 >= 0.8921568627450981 -x322 <= 1.0921568627450982 -x322 <= 1.0 -x323 >= 0.0 -x323 >= 0.4647058823529412 -x323 <= 1.0 -x323 <= 0.6647058823529411 -x324 >= -0.1 -x324 >= 0.0 -x324 <= 1.0 -x324 <= 0.1 -x325 >= -0.1 -x325 >= 0.0 -x325 <= 1.0 -x325 <= 0.1 -x326 >= -0.1 -x326 >= 0.0 -x326 <= 1.0 -x326 <= 0.1 -x327 >= -0.1 -x327 >= 0.0 -x327 <= 1.0 -x327 <= 0.1 +x320 <= 0.1 +x320 <= 0.4980392156862745 +x320 >= -0.5019607843137255 +x320 >= -0.1 +x321 <= 0.007843137254901933 +x321 <= 0.1 +x321 >= -0.9921568627450981 +x321 >= -0.1 +x322 <= 0.007843137254901933 +x322 <= 0.1 +x322 >= -0.9921568627450981 +x322 >= -0.1 +x323 <= 0.6529411764705882 +x323 <= 0.9882352941176471 +x323 >= -0.0117647058823529 +x323 >= 0.4529411764705883 +x324 <= 1.0921568627450982 +x324 <= 1.992156862745098 +x324 >= 0.8921568627450981 +x324 >= 0.9921568627450981 +x325 <= 1.0921568627450982 +x325 <= 1.992156862745098 +x325 >= 0.8921568627450981 +x325 >= 0.9921568627450981 +x326 <= 0.884313725490196 +x326 <= 1.784313725490196 +x326 >= 0.6843137254901961 +x326 >= 0.7843137254901961 +x327 <= 0.17450980392156862 +x327 <= 1.0745098039215686 +x327 >= -0.025490196078431372 +x327 >= 0.07450980392156863 +x328 <= 0.1 +x328 <= 1.0 x328 >= -0.1 x328 >= 0.0 -x328 <= 1.0 -x328 <= 0.1 +x329 <= 0.1 +x329 <= 1.0 x329 >= -0.1 x329 >= 0.0 -x329 <= 1.0 -x329 <= 0.1 +x330 <= 0.1 +x330 <= 1.0 x330 >= -0.1 x330 >= 0.0 -x330 <= 1.0 -x330 <= 0.1 +x331 <= 0.1 +x331 <= 1.0 x331 >= -0.1 x331 >= 0.0 -x331 <= 1.0 -x331 <= 0.1 +x332 <= 0.1 +x332 <= 1.0 x332 >= -0.1 x332 >= 0.0 -x332 <= 1.0 -x332 <= 0.1 +x333 <= 0.1 +x333 <= 1.0 x333 >= -0.1 x333 >= 0.0 -x333 <= 1.0 -x333 <= 0.1 +x334 <= 0.1 +x334 <= 1.0 x334 >= -0.1 x334 >= 0.0 -x334 <= 1.0 -x334 <= 0.1 +x335 <= 0.1 +x335 <= 1.0 x335 >= -0.1 x335 >= 0.0 -x335 <= 1.0 -x335 <= 0.1 +x336 <= 0.1 +x336 <= 1.0 x336 >= -0.1 x336 >= 0.0 -x336 <= 1.0 -x336 <= 0.1 +x337 <= 0.1 +x337 <= 1.0 x337 >= -0.1 x337 >= 0.0 -x337 <= 1.0 -x337 <= 0.1 +x338 <= 0.1 +x338 <= 1.0 x338 >= -0.1 x338 >= 0.0 -x338 <= 1.0 -x338 <= 0.1 +x339 <= 0.1 +x339 <= 1.0 x339 >= -0.1 x339 >= 0.0 -x339 <= 1.0 -x339 <= 0.1 +x340 <= 0.1 +x340 <= 1.0 x340 >= -0.1 x340 >= 0.0 -x340 <= 1.0 -x340 <= 0.1 +x341 <= 0.1 +x341 <= 1.0 x341 >= -0.1 x341 >= 0.0 -x341 <= 1.0 -x341 <= 0.1 +x342 <= 0.1 +x342 <= 1.0 x342 >= -0.1 x342 >= 0.0 -x342 <= 1.0 -x342 <= 0.1 +x343 <= 0.1 +x343 <= 1.0 x343 >= -0.1 x343 >= 0.0 -x343 <= 1.0 -x343 <= 0.1 +x344 <= 0.1 +x344 <= 1.0 x344 >= -0.1 x344 >= 0.0 -x344 <= 1.0 -x344 <= 0.1 +x345 <= 0.1 +x345 <= 1.0 x345 >= -0.1 x345 >= 0.0 -x345 <= 1.0 -x345 <= 0.1 +x346 <= 0.1 +x346 <= 1.0 x346 >= -0.1 x346 >= 0.0 -x346 <= 1.0 -x346 <= 0.1 -x347 >= 0.0 -x347 >= 0.5901960784313726 -x347 <= 1.0 -x347 <= 0.7901960784313725 -x348 >= 0.0 -x348 >= 0.8647058823529412 -x348 <= 1.0647058823529412 -x348 <= 1.0 -x349 >= 0.0 -x349 >= 0.8921568627450981 -x349 <= 1.0921568627450982 -x349 <= 1.0 -x350 >= 0.0 -x350 >= 0.5235294117647059 -x350 <= 1.0 -x350 <= 0.7235294117647059 -x351 >= -0.052941176470588235 -x351 >= 0.0 -x351 <= 1.0 -x351 <= 0.14705882352941177 -x352 >= -0.1 -x352 >= 0.0 -x352 <= 1.0 -x352 <= 0.1 -x353 >= -0.1 -x353 >= 0.0 -x353 <= 1.0 -x353 <= 0.1 -x354 >= -0.1 -x354 >= 0.0 -x354 <= 1.0 -x354 <= 0.1 +x347 <= 0.1 +x347 <= 0.30980392156862746 +x347 >= -0.6901960784313725 +x347 >= -0.1 +x348 <= 0.03529411764705881 +x348 <= 0.1 +x348 >= -0.9647058823529412 +x348 >= -0.1 +x349 <= 0.007843137254901933 +x349 <= 0.1 +x349 >= -0.9921568627450981 +x349 >= -0.1 +x350 <= 0.14705882352941177 +x350 <= 0.4235294117647059 +x350 >= -0.5764705882352941 +x350 >= -0.052941176470588235 +x351 <= 0.8411764705882353 +x351 <= 1.6941176470588235 +x351 >= 0.6411764705882353 +x351 >= 0.6941176470588235 +x352 <= 1.0921568627450982 +x352 <= 1.992156862745098 +x352 >= 0.8921568627450981 +x352 >= 0.9921568627450981 +x353 <= 1.072549019607843 +x353 <= 1.9725490196078432 +x353 >= 0.8725490196078431 +x353 >= 0.9725490196078431 +x354 <= 0.40588235294117647 +x354 <= 1.3058823529411765 +x354 >= 0.2058823529411765 +x354 >= 0.3058823529411765 +x355 <= 0.1 +x355 <= 1.0 x355 >= -0.1 x355 >= 0.0 -x355 <= 1.0 -x355 <= 0.1 +x356 <= 0.1 +x356 <= 1.0 x356 >= -0.1 x356 >= 0.0 -x356 <= 1.0 -x356 <= 0.1 +x357 <= 0.1 +x357 <= 1.0 x357 >= -0.1 x357 >= 0.0 -x357 <= 1.0 -x357 <= 0.1 +x358 <= 0.1 +x358 <= 1.0 x358 >= -0.1 x358 >= 0.0 -x358 <= 1.0 -x358 <= 0.1 +x359 <= 0.1 +x359 <= 1.0 x359 >= -0.1 x359 >= 0.0 -x359 <= 1.0 -x359 <= 0.1 +x360 <= 0.1 +x360 <= 1.0 x360 >= -0.1 x360 >= 0.0 -x360 <= 1.0 -x360 <= 0.1 +x361 <= 0.1 +x361 <= 1.0 x361 >= -0.1 x361 >= 0.0 -x361 <= 1.0 -x361 <= 0.1 +x362 <= 0.1 +x362 <= 1.0 x362 >= -0.1 x362 >= 0.0 -x362 <= 1.0 -x362 <= 0.1 +x363 <= 0.1 +x363 <= 1.0 x363 >= -0.1 x363 >= 0.0 -x363 <= 1.0 -x363 <= 0.1 +x364 <= 0.1 +x364 <= 1.0 x364 >= -0.1 x364 >= 0.0 -x364 <= 1.0 -x364 <= 0.1 +x365 <= 0.1 +x365 <= 1.0 x365 >= -0.1 x365 >= 0.0 -x365 <= 1.0 -x365 <= 0.1 +x366 <= 0.1 +x366 <= 1.0 x366 >= -0.1 x366 >= 0.0 -x366 <= 1.0 -x366 <= 0.1 +x367 <= 0.1 +x367 <= 1.0 x367 >= -0.1 x367 >= 0.0 -x367 <= 1.0 -x367 <= 0.1 +x368 <= 0.1 +x368 <= 1.0 x368 >= -0.1 x368 >= 0.0 -x368 <= 1.0 -x368 <= 0.1 +x369 <= 0.1 +x369 <= 1.0 x369 >= -0.1 x369 >= 0.0 -x369 <= 1.0 -x369 <= 0.1 +x370 <= 0.1 +x370 <= 1.0 x370 >= -0.1 x370 >= 0.0 -x370 <= 1.0 -x370 <= 0.1 +x371 <= 0.1 +x371 <= 1.0 x371 >= -0.1 x371 >= 0.0 -x371 <= 1.0 -x371 <= 0.1 +x372 <= 0.1 +x372 <= 1.0 x372 >= -0.1 x372 >= 0.0 -x372 <= 1.0 -x372 <= 0.1 +x373 <= 0.1 +x373 <= 1.0 x373 >= -0.1 x373 >= 0.0 -x373 <= 1.0 -x373 <= 0.1 -x374 >= -0.0019607843137254915 -x374 >= 0.0 -x374 <= 1.0 -x374 <= 0.1980392156862745 -x375 >= 0.0 -x375 >= 0.8176470588235294 -x375 <= 1.0176470588235293 -x375 <= 1.0 -x376 >= 0.0 -x376 >= 0.8921568627450981 -x376 <= 1.0921568627450982 -x376 <= 1.0 -x377 >= 0.0 -x377 >= 0.8137254901960784 -x377 <= 1.0137254901960784 -x377 <= 1.0 -x378 >= 0.0 -x378 >= 0.03725490196078433 -x378 <= 1.0 -x378 <= 0.23725490196078433 -x379 >= -0.1 -x379 >= 0.0 -x379 <= 1.0 -x379 <= 0.1 -x380 >= -0.1 -x380 >= 0.0 -x380 <= 1.0 -x380 <= 0.1 -x381 >= -0.1 -x381 >= 0.0 -x381 <= 1.0 -x381 <= 0.1 +x374 <= 0.1 +x374 <= 0.9019607843137255 +x374 >= -0.1 +x374 >= -0.09803921568627451 +x375 <= 0.08235294117647063 +x375 <= 0.1 +x375 >= -0.9176470588235294 +x375 >= -0.1 +x376 <= 0.007843137254901933 +x376 <= 0.1 +x376 >= -0.9921568627450981 +x376 >= -0.1 +x377 <= 0.0862745098039216 +x377 <= 0.1 +x377 >= -0.9137254901960784 +x377 >= -0.1 +x378 <= 0.6529411764705882 +x378 <= 1.415686274509804 +x378 >= 0.41568627450980394 +x378 >= 0.4529411764705883 +x379 <= 1.0921568627450982 +x379 <= 1.992156862745098 +x379 >= 0.8921568627450981 +x379 >= 0.9921568627450981 +x380 <= 1.0921568627450982 +x380 <= 1.992156862745098 +x380 >= 0.8921568627450981 +x380 >= 0.9921568627450981 +x381 <= 0.8764705882352941 +x381 <= 1.776470588235294 +x381 >= 0.6764705882352942 +x381 >= 0.7764705882352941 +x382 <= 0.1 +x382 <= 1.0 x382 >= -0.1 x382 >= 0.0 -x382 <= 1.0 -x382 <= 0.1 +x383 <= 0.1 +x383 <= 1.0 x383 >= -0.1 x383 >= 0.0 -x383 <= 1.0 -x383 <= 0.1 +x384 <= 0.1 +x384 <= 1.0 x384 >= -0.1 x384 >= 0.0 -x384 <= 1.0 -x384 <= 0.1 +x385 <= 0.1 +x385 <= 1.0 x385 >= -0.1 x385 >= 0.0 -x385 <= 1.0 -x385 <= 0.1 +x386 <= 0.1 +x386 <= 1.0 x386 >= -0.1 x386 >= 0.0 -x386 <= 1.0 -x386 <= 0.1 +x387 <= 0.1 +x387 <= 1.0 x387 >= -0.1 x387 >= 0.0 -x387 <= 1.0 -x387 <= 0.1 +x388 <= 0.1 +x388 <= 1.0 x388 >= -0.1 x388 >= 0.0 -x388 <= 1.0 -x388 <= 0.1 +x389 <= 0.1 +x389 <= 1.0 x389 >= -0.1 x389 >= 0.0 -x389 <= 1.0 -x389 <= 0.1 +x390 <= 0.1 +x390 <= 1.0 x390 >= -0.1 x390 >= 0.0 -x390 <= 1.0 -x390 <= 0.1 +x391 <= 0.1 +x391 <= 1.0 x391 >= -0.1 x391 >= 0.0 -x391 <= 1.0 -x391 <= 0.1 +x392 <= 0.1 +x392 <= 1.0 x392 >= -0.1 x392 >= 0.0 -x392 <= 1.0 -x392 <= 0.1 +x393 <= 0.1 +x393 <= 1.0 x393 >= -0.1 x393 >= 0.0 -x393 <= 1.0 -x393 <= 0.1 +x394 <= 0.1 +x394 <= 1.0 x394 >= -0.1 x394 >= 0.0 -x394 <= 1.0 -x394 <= 0.1 +x395 <= 0.1 +x395 <= 1.0 x395 >= -0.1 x395 >= 0.0 -x395 <= 1.0 -x395 <= 0.1 +x396 <= 0.1 +x396 <= 1.0 x396 >= -0.1 x396 >= 0.0 -x396 <= 1.0 -x396 <= 0.1 +x397 <= 0.1 +x397 <= 1.0 x397 >= -0.1 x397 >= 0.0 -x397 <= 1.0 -x397 <= 0.1 +x398 <= 0.1 +x398 <= 1.0 x398 >= -0.1 x398 >= 0.0 -x398 <= 1.0 -x398 <= 0.1 +x399 <= 0.1 +x399 <= 1.0 x399 >= -0.1 x399 >= 0.0 -x399 <= 1.0 -x399 <= 0.1 +x400 <= 0.1 +x400 <= 1.0 x400 >= -0.1 x400 >= 0.0 -x400 <= 1.0 -x400 <= 0.1 +x401 <= 0.1 +x401 <= 1.0 x401 >= -0.1 x401 >= 0.0 -x401 <= 1.0 -x401 <= 0.1 -x402 >= 0.0 -x402 >= 0.6764705882352942 -x402 <= 1.0 -x402 <= 0.8764705882352941 -x403 >= 0.0 -x403 >= 0.8921568627450981 -x403 <= 1.0921568627450982 -x403 <= 1.0 -x404 >= 0.0 -x404 >= 0.8921568627450981 -x404 <= 1.0921568627450982 -x404 <= 1.0 -x405 >= 0.0 -x405 >= 0.4529411764705883 -x405 <= 1.0 -x405 <= 0.6529411764705882 -x406 >= -0.1 -x406 >= 0.0 -x406 <= 1.0 -x406 <= 0.1 -x407 >= -0.1 -x407 >= 0.0 -x407 <= 1.0 -x407 <= 0.1 -x408 >= -0.1 -x408 >= 0.0 -x408 <= 1.0 -x408 <= 0.1 -x409 >= -0.1 -x409 >= 0.0 -x409 <= 1.0 -x409 <= 0.1 +x402 <= 0.1 +x402 <= 0.22352941176470587 +x402 >= -0.7764705882352941 +x402 >= -0.1 +x403 <= 0.007843137254901933 +x403 <= 0.1 +x403 >= -0.9921568627450981 +x403 >= -0.1 +x404 <= 0.007843137254901933 +x404 <= 0.1 +x404 >= -0.9921568627450981 +x404 >= -0.1 +x405 <= 0.23725490196078433 +x405 <= 0.584313725490196 +x405 >= -0.41568627450980394 +x405 >= 0.03725490196078433 +x406 <= 1.0137254901960784 +x406 <= 1.9137254901960783 +x406 >= 0.8137254901960784 +x406 >= 0.9137254901960784 +x407 <= 1.0921568627450982 +x407 <= 1.992156862745098 +x407 >= 0.8921568627450981 +x407 >= 0.9921568627450981 +x408 <= 1.0176470588235293 +x408 <= 1.9176470588235293 +x408 >= 0.8176470588235294 +x408 >= 0.9176470588235294 +x409 <= 0.1980392156862745 +x409 <= 1.0980392156862746 +x409 >= -0.0019607843137254915 +x409 >= 0.09803921568627451 +x410 <= 0.1 +x410 <= 1.0 x410 >= -0.1 x410 >= 0.0 -x410 <= 1.0 -x410 <= 0.1 +x411 <= 0.1 +x411 <= 1.0 x411 >= -0.1 x411 >= 0.0 -x411 <= 1.0 -x411 <= 0.1 +x412 <= 0.1 +x412 <= 1.0 x412 >= -0.1 x412 >= 0.0 -x412 <= 1.0 -x412 <= 0.1 +x413 <= 0.1 +x413 <= 1.0 x413 >= -0.1 x413 >= 0.0 -x413 <= 1.0 -x413 <= 0.1 +x414 <= 0.1 +x414 <= 1.0 x414 >= -0.1 x414 >= 0.0 -x414 <= 1.0 -x414 <= 0.1 +x415 <= 0.1 +x415 <= 1.0 x415 >= -0.1 x415 >= 0.0 -x415 <= 1.0 -x415 <= 0.1 +x416 <= 0.1 +x416 <= 1.0 x416 >= -0.1 x416 >= 0.0 -x416 <= 1.0 -x416 <= 0.1 +x417 <= 0.1 +x417 <= 1.0 x417 >= -0.1 x417 >= 0.0 -x417 <= 1.0 -x417 <= 0.1 +x418 <= 0.1 +x418 <= 1.0 x418 >= -0.1 x418 >= 0.0 -x418 <= 1.0 -x418 <= 0.1 +x419 <= 0.1 +x419 <= 1.0 x419 >= -0.1 x419 >= 0.0 -x419 <= 1.0 -x419 <= 0.1 +x420 <= 0.1 +x420 <= 1.0 x420 >= -0.1 x420 >= 0.0 -x420 <= 1.0 -x420 <= 0.1 +x421 <= 0.1 +x421 <= 1.0 x421 >= -0.1 x421 >= 0.0 -x421 <= 1.0 -x421 <= 0.1 +x422 <= 0.1 +x422 <= 1.0 x422 >= -0.1 x422 >= 0.0 -x422 <= 1.0 -x422 <= 0.1 +x423 <= 0.1 +x423 <= 1.0 x423 >= -0.1 x423 >= 0.0 -x423 <= 1.0 -x423 <= 0.1 +x424 <= 0.1 +x424 <= 1.0 x424 >= -0.1 x424 >= 0.0 -x424 <= 1.0 -x424 <= 0.1 +x425 <= 0.1 +x425 <= 1.0 x425 >= -0.1 x425 >= 0.0 -x425 <= 1.0 -x425 <= 0.1 +x426 <= 0.1 +x426 <= 1.0 x426 >= -0.1 x426 >= 0.0 -x426 <= 1.0 -x426 <= 0.1 +x427 <= 0.1 +x427 <= 1.0 x427 >= -0.1 x427 >= 0.0 -x427 <= 1.0 -x427 <= 0.1 +x428 <= 0.1 +x428 <= 1.0 x428 >= -0.1 x428 >= 0.0 -x428 <= 1.0 -x428 <= 0.1 -x429 >= 0.0 -x429 >= 0.2058823529411765 -x429 <= 1.0 -x429 <= 0.40588235294117647 -x430 >= 0.0 -x430 >= 0.8725490196078431 -x430 <= 1.072549019607843 -x430 <= 1.0 -x431 >= 0.0 -x431 >= 0.8921568627450981 -x431 <= 1.0921568627450982 -x431 <= 1.0 -x432 >= 0.0 -x432 >= 0.6411764705882353 -x432 <= 1.0 -x432 <= 0.8411764705882353 -x433 >= -0.052941176470588235 -x433 >= 0.0 -x433 <= 1.0 -x433 <= 0.14705882352941177 -x434 >= -0.1 -x434 >= 0.0 -x434 <= 1.0 -x434 <= 0.1 -x435 >= -0.1 -x435 >= 0.0 -x435 <= 1.0 -x435 <= 0.1 -x436 >= -0.1 -x436 >= 0.0 -x436 <= 1.0 -x436 <= 0.1 +x429 <= 0.1 +x429 <= 0.6941176470588235 +x429 >= -0.3058823529411765 +x429 >= -0.1 +x430 <= 0.027450980392156876 +x430 <= 0.1 +x430 >= -0.9725490196078431 +x430 >= -0.1 +x431 <= 0.007843137254901933 +x431 <= 0.1 +x431 >= -0.9921568627450981 +x431 >= -0.1 +x432 <= 0.14705882352941177 +x432 <= 0.30588235294117644 +x432 >= -0.6941176470588235 +x432 >= -0.052941176470588235 +x433 <= 0.7235294117647059 +x433 <= 1.576470588235294 +x433 >= 0.5235294117647059 +x433 >= 0.5764705882352941 +x434 <= 1.0921568627450982 +x434 <= 1.992156862745098 +x434 >= 0.8921568627450981 +x434 >= 0.9921568627450981 +x435 <= 1.0647058823529412 +x435 <= 1.9647058823529413 +x435 >= 0.8647058823529412 +x435 >= 0.9647058823529412 +x436 <= 0.7901960784313725 +x436 <= 1.6901960784313725 +x436 >= 0.5901960784313726 +x436 >= 0.6901960784313725 +x437 <= 0.1 +x437 <= 1.0 x437 >= -0.1 x437 >= 0.0 -x437 <= 1.0 -x437 <= 0.1 +x438 <= 0.1 +x438 <= 1.0 x438 >= -0.1 x438 >= 0.0 -x438 <= 1.0 -x438 <= 0.1 +x439 <= 0.1 +x439 <= 1.0 x439 >= -0.1 x439 >= 0.0 -x439 <= 1.0 -x439 <= 0.1 +x440 <= 0.1 +x440 <= 1.0 x440 >= -0.1 x440 >= 0.0 -x440 <= 1.0 -x440 <= 0.1 +x441 <= 0.1 +x441 <= 1.0 x441 >= -0.1 x441 >= 0.0 -x441 <= 1.0 -x441 <= 0.1 +x442 <= 0.1 +x442 <= 1.0 x442 >= -0.1 x442 >= 0.0 -x442 <= 1.0 -x442 <= 0.1 +x443 <= 0.1 +x443 <= 1.0 x443 >= -0.1 x443 >= 0.0 -x443 <= 1.0 -x443 <= 0.1 +x444 <= 0.1 +x444 <= 1.0 x444 >= -0.1 x444 >= 0.0 -x444 <= 1.0 -x444 <= 0.1 +x445 <= 0.1 +x445 <= 1.0 x445 >= -0.1 x445 >= 0.0 -x445 <= 1.0 -x445 <= 0.1 +x446 <= 0.1 +x446 <= 1.0 x446 >= -0.1 x446 >= 0.0 -x446 <= 1.0 -x446 <= 0.1 +x447 <= 0.1 +x447 <= 1.0 x447 >= -0.1 x447 >= 0.0 -x447 <= 1.0 -x447 <= 0.1 +x448 <= 0.1 +x448 <= 1.0 x448 >= -0.1 x448 >= 0.0 -x448 <= 1.0 -x448 <= 0.1 +x449 <= 0.1 +x449 <= 1.0 x449 >= -0.1 x449 >= 0.0 -x449 <= 1.0 -x449 <= 0.1 +x450 <= 0.1 +x450 <= 1.0 x450 >= -0.1 x450 >= 0.0 -x450 <= 1.0 -x450 <= 0.1 +x451 <= 0.1 +x451 <= 1.0 x451 >= -0.1 x451 >= 0.0 -x451 <= 1.0 -x451 <= 0.1 +x452 <= 0.1 +x452 <= 1.0 x452 >= -0.1 x452 >= 0.0 -x452 <= 1.0 -x452 <= 0.1 +x453 <= 0.1 +x453 <= 1.0 x453 >= -0.1 x453 >= 0.0 -x453 <= 1.0 -x453 <= 0.1 +x454 <= 0.1 +x454 <= 1.0 x454 >= -0.1 x454 >= 0.0 -x454 <= 1.0 -x454 <= 0.1 +x455 <= 0.1 +x455 <= 1.0 x455 >= -0.1 x455 >= 0.0 -x455 <= 1.0 -x455 <= 0.1 -x456 >= -0.025490196078431372 -x456 >= 0.0 -x456 <= 1.0 -x456 <= 0.17450980392156862 -x457 >= 0.0 -x457 >= 0.6843137254901961 -x457 <= 1.0 -x457 <= 0.884313725490196 -x458 >= 0.0 -x458 >= 0.8921568627450981 -x458 <= 1.0921568627450982 -x458 <= 1.0 -x459 >= 0.0 -x459 >= 0.8921568627450981 -x459 <= 1.0921568627450982 -x459 <= 1.0 -x460 >= 0.0 -x460 >= 0.4529411764705883 -x460 <= 1.0 -x460 <= 0.6529411764705882 -x461 >= -0.1 -x461 >= 0.0 -x461 <= 1.0 -x461 <= 0.1 -x462 >= -0.1 -x462 >= 0.0 -x462 <= 1.0 -x462 <= 0.1 -x463 >= -0.1 -x463 >= 0.0 -x463 <= 1.0 -x463 <= 0.1 +x456 <= 0.1 +x456 <= 0.9254901960784314 +x456 >= -0.1 +x456 >= -0.07450980392156863 +x457 <= 0.1 +x457 <= 0.21568627450980393 +x457 >= -0.7843137254901961 +x457 >= -0.1 +x458 <= 0.007843137254901933 +x458 <= 0.1 +x458 >= -0.9921568627450981 +x458 >= -0.1 +x459 <= 0.007843137254901933 +x459 <= 0.1 +x459 >= -0.9921568627450981 +x459 >= -0.1 +x460 <= 0.6647058823529411 +x460 <= 1.011764705882353 +x460 >= 0.0117647058823529 +x460 >= 0.4647058823529412 +x461 <= 1.0921568627450982 +x461 <= 1.992156862745098 +x461 >= 0.8921568627450981 +x461 >= 0.9921568627450981 +x462 <= 1.0921568627450982 +x462 <= 1.992156862745098 +x462 >= 0.8921568627450981 +x462 >= 0.9921568627450981 +x463 <= 0.6019607843137255 +x463 <= 1.5019607843137255 +x463 >= 0.4019607843137255 +x463 >= 0.5019607843137255 +x464 <= 0.1 +x464 <= 1.0 x464 >= -0.1 x464 >= 0.0 -x464 <= 1.0 -x464 <= 0.1 +x465 <= 0.1 +x465 <= 1.0 x465 >= -0.1 x465 >= 0.0 -x465 <= 1.0 -x465 <= 0.1 +x466 <= 0.1 +x466 <= 1.0 x466 >= -0.1 x466 >= 0.0 -x466 <= 1.0 -x466 <= 0.1 +x467 <= 0.1 +x467 <= 1.0 x467 >= -0.1 x467 >= 0.0 -x467 <= 1.0 -x467 <= 0.1 +x468 <= 0.1 +x468 <= 1.0 x468 >= -0.1 x468 >= 0.0 -x468 <= 1.0 -x468 <= 0.1 +x469 <= 0.1 +x469 <= 1.0 x469 >= -0.1 x469 >= 0.0 -x469 <= 1.0 -x469 <= 0.1 +x470 <= 0.1 +x470 <= 1.0 x470 >= -0.1 x470 >= 0.0 -x470 <= 1.0 -x470 <= 0.1 +x471 <= 0.1 +x471 <= 1.0 x471 >= -0.1 x471 >= 0.0 -x471 <= 1.0 -x471 <= 0.1 +x472 <= 0.1 +x472 <= 1.0 x472 >= -0.1 x472 >= 0.0 -x472 <= 1.0 -x472 <= 0.1 +x473 <= 0.1 +x473 <= 1.0 x473 >= -0.1 x473 >= 0.0 -x473 <= 1.0 -x473 <= 0.1 +x474 <= 0.1 +x474 <= 1.0 x474 >= -0.1 x474 >= 0.0 -x474 <= 1.0 -x474 <= 0.1 +x475 <= 0.1 +x475 <= 1.0 x475 >= -0.1 x475 >= 0.0 -x475 <= 1.0 -x475 <= 0.1 +x476 <= 0.1 +x476 <= 1.0 x476 >= -0.1 x476 >= 0.0 -x476 <= 1.0 -x476 <= 0.1 +x477 <= 0.1 +x477 <= 1.0 x477 >= -0.1 x477 >= 0.0 -x477 <= 1.0 -x477 <= 0.1 +x478 <= 0.1 +x478 <= 1.0 x478 >= -0.1 x478 >= 0.0 -x478 <= 1.0 -x478 <= 0.1 +x479 <= 0.1 +x479 <= 1.0 x479 >= -0.1 x479 >= 0.0 -x479 <= 1.0 -x479 <= 0.1 +x480 <= 0.1 +x480 <= 1.0 x480 >= -0.1 x480 >= 0.0 -x480 <= 1.0 -x480 <= 0.1 +x481 <= 0.1 +x481 <= 1.0 x481 >= -0.1 x481 >= 0.0 -x481 <= 1.0 -x481 <= 0.1 +x482 <= 0.1 +x482 <= 1.0 x482 >= -0.1 x482 >= 0.0 -x482 <= 1.0 -x482 <= 0.1 +x483 <= 0.1 +x483 <= 1.0 x483 >= -0.1 x483 >= 0.0 -x483 <= 1.0 -x483 <= 0.1 -x484 >= 0.0 -x484 >= 0.4254901960784314 -x484 <= 1.0 -x484 <= 0.6254901960784314 -x485 >= 0.0 -x485 >= 0.8921568627450981 -x485 <= 1.0921568627450982 -x485 <= 1.0 -x486 >= 0.0 -x486 >= 0.8921568627450981 -x486 <= 1.0921568627450982 -x486 <= 1.0 -x487 >= 0.0 -x487 >= 0.5784313725490197 -x487 <= 1.0 -x487 <= 0.7784313725490196 -x488 >= -0.052941176470588235 -x488 >= 0.0 -x488 <= 1.0 -x488 <= 0.14705882352941177 -x489 >= -0.1 -x489 >= 0.0 -x489 <= 1.0 -x489 <= 0.1 -x490 >= -0.1 -x490 >= 0.0 -x490 <= 1.0 -x490 <= 0.1 -x491 >= -0.1 -x491 >= 0.0 -x491 <= 1.0 -x491 <= 0.1 +x484 <= 0.1 +x484 <= 0.4745098039215686 +x484 >= -0.5254901960784314 +x484 >= -0.1 +x485 <= 0.007843137254901933 +x485 <= 0.1 +x485 >= -0.9921568627450981 +x485 >= -0.1 +x486 <= 0.007843137254901933 +x486 <= 0.1 +x486 >= -0.9921568627450981 +x486 >= -0.1 +x487 <= 0.34705882352941175 +x487 <= 0.5686274509803921 +x487 >= -0.43137254901960786 +x487 >= 0.14705882352941177 +x488 <= 1.0058823529411764 +x488 <= 1.8588235294117648 +x488 >= 0.8058823529411765 +x488 >= 0.8588235294117648 +x489 <= 1.0921568627450982 +x489 <= 1.992156862745098 +x489 >= 0.8921568627450981 +x489 >= 0.9921568627450981 +x490 <= 1.0686274509803921 +x490 <= 1.9686274509803923 +x490 >= 0.8686274509803922 +x490 >= 0.9686274509803922 +x491 <= 0.3980392156862745 +x491 <= 1.2980392156862746 +x491 >= 0.1980392156862745 +x491 >= 0.2980392156862745 +x492 <= 0.1 +x492 <= 1.0 x492 >= -0.1 x492 >= 0.0 -x492 <= 1.0 -x492 <= 0.1 +x493 <= 0.1 +x493 <= 1.0 x493 >= -0.1 x493 >= 0.0 -x493 <= 1.0 -x493 <= 0.1 +x494 <= 0.1 +x494 <= 1.0 x494 >= -0.1 x494 >= 0.0 -x494 <= 1.0 -x494 <= 0.1 +x495 <= 0.1 +x495 <= 1.0 x495 >= -0.1 x495 >= 0.0 -x495 <= 1.0 -x495 <= 0.1 +x496 <= 0.1 +x496 <= 1.0 x496 >= -0.1 x496 >= 0.0 -x496 <= 1.0 -x496 <= 0.1 +x497 <= 0.1 +x497 <= 1.0 x497 >= -0.1 x497 >= 0.0 -x497 <= 1.0 -x497 <= 0.1 +x498 <= 0.1 +x498 <= 1.0 x498 >= -0.1 x498 >= 0.0 -x498 <= 1.0 -x498 <= 0.1 +x499 <= 0.1 +x499 <= 1.0 x499 >= -0.1 x499 >= 0.0 -x499 <= 1.0 -x499 <= 0.1 +x500 <= 0.1 +x500 <= 1.0 x500 >= -0.1 x500 >= 0.0 -x500 <= 1.0 -x500 <= 0.1 +x501 <= 0.1 +x501 <= 1.0 x501 >= -0.1 x501 >= 0.0 -x501 <= 1.0 -x501 <= 0.1 +x502 <= 0.1 +x502 <= 1.0 x502 >= -0.1 x502 >= 0.0 -x502 <= 1.0 -x502 <= 0.1 +x503 <= 0.1 +x503 <= 1.0 x503 >= -0.1 x503 >= 0.0 -x503 <= 1.0 -x503 <= 0.1 +x504 <= 0.1 +x504 <= 1.0 x504 >= -0.1 x504 >= 0.0 -x504 <= 1.0 -x504 <= 0.1 +x505 <= 0.1 +x505 <= 1.0 x505 >= -0.1 x505 >= 0.0 -x505 <= 1.0 -x505 <= 0.1 +x506 <= 0.1 +x506 <= 1.0 x506 >= -0.1 x506 >= 0.0 -x506 <= 1.0 -x506 <= 0.1 +x507 <= 0.1 +x507 <= 1.0 x507 >= -0.1 x507 >= 0.0 -x507 <= 1.0 -x507 <= 0.1 +x508 <= 0.1 +x508 <= 1.0 x508 >= -0.1 x508 >= 0.0 -x508 <= 1.0 -x508 <= 0.1 +x509 <= 0.1 +x509 <= 1.0 x509 >= -0.1 x509 >= 0.0 -x509 <= 1.0 -x509 <= 0.1 +x510 <= 0.1 +x510 <= 1.0 x510 >= -0.1 x510 >= 0.0 -x510 <= 1.0 -x510 <= 0.1 +x511 <= 0.1 +x511 <= 1.0 x511 >= -0.1 x511 >= 0.0 -x511 <= 1.0 -x511 <= 0.1 -x512 >= 0.0 -x512 >= 0.8725490196078431 -x512 <= 1.072549019607843 -x512 <= 1.0 -x513 >= 0.0 -x513 >= 0.8921568627450981 -x513 <= 1.0921568627450982 -x513 <= 1.0 -x514 >= 0.0 -x514 >= 0.8921568627450981 -x514 <= 1.0921568627450982 -x514 <= 1.0 -x515 >= -0.0019607843137254915 -x515 >= 0.0 -x515 <= 1.0 -x515 <= 0.1980392156862745 -x516 >= -0.1 -x516 >= 0.0 -x516 <= 1.0 -x516 <= 0.1 -x517 >= -0.1 -x517 >= 0.0 -x517 <= 1.0 -x517 <= 0.1 -x518 >= -0.1 -x518 >= 0.0 -x518 <= 1.0 -x518 <= 0.1 +x512 <= 0.027450980392156876 +x512 <= 0.1 +x512 >= -0.9725490196078431 +x512 >= -0.1 +x513 <= 0.007843137254901933 +x513 <= 0.1 +x513 >= -0.9921568627450981 +x513 >= -0.1 +x514 <= 0.047058823529411736 +x514 <= 0.1392156862745098 +x514 >= -0.9529411764705883 +x514 >= -0.060784313725490195 +x515 <= 0.8764705882352941 +x515 <= 1.6784313725490196 +x515 >= 0.6764705882352942 +x515 >= 0.6784313725490196 +x516 <= 1.0921568627450982 +x516 <= 1.992156862745098 +x516 >= 0.8921568627450981 +x516 >= 0.9921568627450981 +x517 <= 1.0686274509803921 +x517 <= 1.9686274509803923 +x517 >= 0.8686274509803922 +x517 >= 0.9686274509803922 +x518 <= 0.5588235294117647 +x518 <= 1.4588235294117646 +x518 >= 0.3588235294117647 +x518 >= 0.4588235294117647 +x519 <= 0.1 +x519 <= 1.0 x519 >= -0.1 x519 >= 0.0 -x519 <= 1.0 -x519 <= 0.1 +x520 <= 0.1 +x520 <= 1.0 x520 >= -0.1 x520 >= 0.0 -x520 <= 1.0 -x520 <= 0.1 +x521 <= 0.1 +x521 <= 1.0 x521 >= -0.1 x521 >= 0.0 -x521 <= 1.0 -x521 <= 0.1 +x522 <= 0.1 +x522 <= 1.0 x522 >= -0.1 x522 >= 0.0 -x522 <= 1.0 -x522 <= 0.1 +x523 <= 0.1 +x523 <= 1.0 x523 >= -0.1 x523 >= 0.0 -x523 <= 1.0 -x523 <= 0.1 +x524 <= 0.1 +x524 <= 1.0 x524 >= -0.1 x524 >= 0.0 -x524 <= 1.0 -x524 <= 0.1 +x525 <= 0.1 +x525 <= 1.0 x525 >= -0.1 x525 >= 0.0 -x525 <= 1.0 -x525 <= 0.1 +x526 <= 0.1 +x526 <= 1.0 x526 >= -0.1 x526 >= 0.0 -x526 <= 1.0 -x526 <= 0.1 +x527 <= 0.1 +x527 <= 1.0 x527 >= -0.1 x527 >= 0.0 -x527 <= 1.0 -x527 <= 0.1 +x528 <= 0.1 +x528 <= 1.0 x528 >= -0.1 x528 >= 0.0 -x528 <= 1.0 -x528 <= 0.1 +x529 <= 0.1 +x529 <= 1.0 x529 >= -0.1 x529 >= 0.0 -x529 <= 1.0 -x529 <= 0.1 +x530 <= 0.1 +x530 <= 1.0 x530 >= -0.1 x530 >= 0.0 -x530 <= 1.0 -x530 <= 0.1 +x531 <= 0.1 +x531 <= 1.0 x531 >= -0.1 x531 >= 0.0 -x531 <= 1.0 -x531 <= 0.1 +x532 <= 0.1 +x532 <= 1.0 x532 >= -0.1 x532 >= 0.0 -x532 <= 1.0 -x532 <= 0.1 +x533 <= 0.1 +x533 <= 1.0 x533 >= -0.1 x533 >= 0.0 -x533 <= 1.0 -x533 <= 0.1 +x534 <= 0.1 +x534 <= 1.0 x534 >= -0.1 x534 >= 0.0 -x534 <= 1.0 -x534 <= 0.1 +x535 <= 0.1 +x535 <= 1.0 x535 >= -0.1 x535 >= 0.0 -x535 <= 1.0 -x535 <= 0.1 +x536 <= 0.1 +x536 <= 1.0 x536 >= -0.1 x536 >= 0.0 -x536 <= 1.0 -x536 <= 0.1 +x537 <= 0.1 +x537 <= 1.0 x537 >= -0.1 x537 >= 0.0 -x537 <= 1.0 -x537 <= 0.1 +x538 <= 0.1 +x538 <= 1.0 x538 >= -0.1 x538 >= 0.0 -x538 <= 1.0 -x538 <= 0.1 +x539 <= 0.1 +x539 <= 1.0 x539 >= -0.1 x539 >= 0.0 -x539 <= 1.0 -x539 <= 0.1 -x540 >= 0.0 -x540 >= 0.8725490196078431 -x540 <= 1.072549019607843 -x540 <= 1.0 -x541 >= 0.0 -x541 >= 0.8921568627450981 -x541 <= 1.0921568627450982 -x541 <= 1.0 -x542 >= 0.0 -x542 >= 0.8921568627450981 -x542 <= 1.0921568627450982 -x542 <= 1.0 -x543 >= 0.0 -x543 >= 0.06862745098039216 -x543 <= 1.0 -x543 <= 0.26862745098039215 -x544 >= -0.021568627450980392 -x544 >= 0.0 -x544 <= 1.0 -x544 <= 0.1784313725490196 -x545 >= -0.021568627450980392 -x545 >= 0.0 -x545 <= 1.0 -x545 <= 0.1784313725490196 -x546 >= -0.021568627450980392 -x546 >= 0.0 -x546 <= 1.0 -x546 <= 0.1784313725490196 -x547 >= -0.021568627450980392 -x547 >= 0.0 -x547 <= 1.0 -x547 <= 0.1784313725490196 -x548 >= -0.0803921568627451 -x548 >= 0.0 -x548 <= 1.0 -x548 <= 0.11960784313725491 +x540 <= 0.027450980392156876 +x540 <= 0.1 +x540 >= -0.9725490196078431 +x540 >= -0.1 +x541 <= 0.007843137254901933 +x541 <= 0.1 +x541 >= -0.9921568627450981 +x541 >= -0.1 +x542 <= 0.26274509803921564 +x542 <= 0.3549019607843137 +x542 >= -0.7372549019607844 +x542 >= 0.1549019607843137 +x543 <= 1.0921568627450982 +x543 <= 1.8235294117647058 +x543 >= 0.8235294117647058 +x543 >= 0.8921568627450981 +x544 <= 1.0921568627450982 +x544 <= 1.9137254901960785 +x544 >= 0.8921568627450981 +x544 >= 0.9137254901960785 +x545 <= 0.9196078431372549 +x545 <= 1.7411764705882353 +x545 >= 0.7196078431372549 +x545 >= 0.7411764705882353 +x546 <= 0.1 +x546 <= 0.9215686274509804 +x546 >= -0.1 +x546 >= -0.0784313725490196 +x547 <= 0.1 +x547 <= 0.9215686274509804 +x547 >= -0.1 +x547 >= -0.0784313725490196 +x548 <= 0.1 +x548 <= 0.9803921568627451 +x548 >= -0.1 +x548 >= -0.0196078431372549 +x549 <= 0.1 +x549 <= 1.0 x549 >= -0.1 x549 >= 0.0 -x549 <= 1.0 -x549 <= 0.1 -x550 >= -0.0803921568627451 -x550 >= 0.0 -x550 <= 1.0 -x550 <= 0.11960784313725491 -x551 >= -0.021568627450980392 -x551 >= 0.0 -x551 <= 1.0 -x551 <= 0.1784313725490196 -x552 >= -0.021568627450980392 -x552 >= 0.0 -x552 <= 1.0 -x552 <= 0.1784313725490196 -x553 >= 0.0 -x553 >= 0.04509803921568629 -x553 <= 1.0 -x553 <= 0.2450980392156863 -x554 >= 0.0 -x554 >= 0.4882352941176471 -x554 <= 1.0 -x554 <= 0.6882352941176471 -x555 >= 0.0 -x555 >= 0.4882352941176471 -x555 <= 1.0 -x555 <= 0.6882352941176471 -x556 >= 0.0 -x556 >= 0.4882352941176471 -x556 <= 1.0 -x556 <= 0.6882352941176471 -x557 >= 0.0 -x557 >= 0.4764705882352941 -x557 <= 1.0 -x557 <= 0.676470588235294 -x558 >= -0.060784313725490195 -x558 >= 0.0 -x558 <= 1.0 -x558 <= 0.1392156862745098 +x550 <= 0.17058823529411765 +x550 <= 1.0509803921568628 +x550 >= -0.029411764705882353 +x550 >= 0.050980392156862744 +x551 <= 0.22156862745098038 +x551 <= 1.0431372549019609 +x551 >= 0.021568627450980392 +x551 >= 0.043137254901960784 +x552 <= 0.1 +x552 <= 0.9215686274509804 +x552 >= -0.1 +x552 >= -0.0784313725490196 +x553 <= 0.1 +x553 <= 0.8549019607843137 +x553 >= -0.1450980392156863 +x553 >= -0.1 +x554 <= 0.1 +x554 <= 0.4117647058823529 +x554 >= -0.5882352941176471 +x554 >= -0.1 +x555 <= 0.1 +x555 <= 0.4117647058823529 +x555 >= -0.5882352941176471 +x555 >= -0.1 +x556 <= 0.1 +x556 <= 0.4117647058823529 +x556 >= -0.5882352941176471 +x556 >= -0.1 +x557 <= 0.1 +x557 <= 0.42352941176470593 +x557 >= -0.5764705882352941 +x557 >= -0.1 +x558 <= 0.1 +x558 <= 0.9607843137254902 +x558 >= -0.1 +x558 >= -0.0392156862745098 +x559 <= 0.1 +x559 <= 1.0 x559 >= -0.1 x559 >= 0.0 -x559 <= 1.0 -x559 <= 0.1 +x560 <= 0.1 +x560 <= 1.0 x560 >= -0.1 x560 >= 0.0 -x560 <= 1.0 -x560 <= 0.1 +x561 <= 0.1 +x561 <= 1.0 x561 >= -0.1 x561 >= 0.0 -x561 <= 1.0 -x561 <= 0.1 +x562 <= 0.1 +x562 <= 1.0 x562 >= -0.1 x562 >= 0.0 -x562 <= 1.0 -x562 <= 0.1 +x563 <= 0.1 +x563 <= 1.0 x563 >= -0.1 x563 >= 0.0 -x563 <= 1.0 -x563 <= 0.1 +x564 <= 0.1 +x564 <= 1.0 x564 >= -0.1 x564 >= 0.0 -x564 <= 1.0 -x564 <= 0.1 +x565 <= 0.1 +x565 <= 1.0 x565 >= -0.1 x565 >= 0.0 -x565 <= 1.0 -x565 <= 0.1 +x566 <= 0.1 +x566 <= 1.0 x566 >= -0.1 x566 >= 0.0 -x566 <= 1.0 -x566 <= 0.1 +x567 <= 0.1 +x567 <= 1.0 x567 >= -0.1 x567 >= 0.0 -x567 <= 1.0 -x567 <= 0.1 -x568 >= 0.0 -x568 >= 0.8725490196078431 -x568 <= 1.072549019607843 -x568 <= 1.0 -x569 >= 0.0 -x569 >= 0.8921568627450981 -x569 <= 1.0921568627450982 -x569 <= 1.0 -x570 >= 0.0 -x570 >= 0.8921568627450981 -x570 <= 1.0921568627450982 -x570 <= 1.0 +x568 <= 0.027450980392156876 +x568 <= 0.1 +x568 >= -0.9725490196078431 +x568 >= -0.1 +x569 <= 0.007843137254901933 +x569 <= 0.1 +x569 >= -0.9921568627450981 +x569 >= -0.1 +x570 <= 0.26274509803921564 +x570 <= 0.3549019607843137 +x570 >= -0.7372549019607844 +x570 >= 0.1549019607843137 +x571 <= 1.0 +x571 <= 1.0921568627450982 x571 >= 0.0 x571 >= 0.8921568627450981 -x571 <= 1.0921568627450982 -x571 <= 1.0 -x572 >= 0.0 -x572 >= 0.8921568627450981 -x572 <= 1.0921568627450982 -x572 <= 1.0 -x573 >= 0.0 -x573 >= 0.8921568627450981 -x573 <= 1.0921568627450982 -x573 <= 1.0 -x574 >= 0.0 -x574 >= 0.8921568627450981 -x574 <= 1.0921568627450982 -x574 <= 1.0 -x575 >= 0.0 -x575 >= 0.8921568627450981 -x575 <= 1.0921568627450982 -x575 <= 1.0 -x576 >= 0.0 -x576 >= 0.5588235294117647 -x576 <= 1.0 -x576 <= 0.7588235294117647 -x577 >= 0.0 -x577 >= 0.4607843137254902 -x577 <= 1.0 -x577 <= 0.6607843137254902 -x578 >= 0.0 -x578 >= 0.5509803921568628 -x578 <= 1.0 -x578 <= 0.7509803921568627 -x579 >= 0.0 -x579 >= 0.8921568627450981 -x579 <= 1.0921568627450982 -x579 <= 1.0 -x580 >= 0.0 -x580 >= 0.8921568627450981 -x580 <= 1.0921568627450982 -x580 <= 1.0 -x581 >= 0.0 -x581 >= 0.8921568627450981 -x581 <= 1.0921568627450982 -x581 <= 1.0 -x582 >= 0.0 -x582 >= 0.8921568627450981 -x582 <= 1.0921568627450982 -x582 <= 1.0 -x583 >= 0.0 -x583 >= 0.8921568627450981 -x583 <= 1.0921568627450982 -x583 <= 1.0 -x584 >= 0.0 -x584 >= 0.8921568627450981 -x584 <= 1.0921568627450982 -x584 <= 1.0 -x585 >= 0.0 -x585 >= 0.8921568627450981 -x585 <= 1.0921568627450982 -x585 <= 1.0 -x586 >= 0.0 -x586 >= 0.3823529411764706 -x586 <= 1.0 -x586 <= 0.5823529411764706 +x572 <= 0.9803921568627451 +x572 <= 1.072549019607843 +x572 >= -0.019607843137254943 +x572 >= 0.8725490196078431 +x573 <= 0.48627450980392156 +x573 <= 0.5784313725490197 +x573 >= -0.5137254901960784 +x573 >= 0.37843137254901965 +x574 <= 0.007843137254901933 +x574 <= 0.1 +x574 >= -0.9921568627450981 +x574 >= -0.1 +x575 <= 0.007843137254901933 +x575 <= 0.1 +x575 >= -0.9921568627450981 +x575 >= -0.1 +x576 <= 0.1 +x576 <= 0.3411764705882353 +x576 >= -0.6588235294117647 +x576 >= -0.1 +x577 <= 0.1980392156862745 +x577 <= 0.5372549019607843 +x577 >= -0.4627450980392157 +x577 >= -0.0019607843137254915 +x578 <= 0.9235294117647058 +x578 <= 1.172549019607843 +x578 >= 0.17254901960784308 +x578 >= 0.7235294117647059 +x579 <= 0.992156862745098 +x579 <= 1.084313725490196 +x579 >= -0.007843137254902044 +x579 >= 0.884313725490196 +x580 <= 0.3098039215686274 +x580 <= 0.40196078431372545 +x580 >= -0.6901960784313725 +x580 >= 0.20196078431372547 +x581 <= 0.007843137254901933 +x581 <= 0.1 +x581 >= -0.9921568627450981 +x581 >= -0.1 +x582 <= 0.007843137254901933 +x582 <= 0.1 +x582 >= -0.9921568627450981 +x582 >= -0.1 +x583 <= 0.007843137254901933 +x583 <= 0.1 +x583 >= -0.9921568627450981 +x583 >= -0.1 +x584 <= 0.007843137254901933 +x584 <= 0.1 +x584 >= -0.9921568627450981 +x584 >= -0.1 +x585 <= 0.007843137254901933 +x585 <= 0.1 +x585 >= -0.9921568627450981 +x585 >= -0.1 +x586 <= 0.1 +x586 <= 0.5176470588235293 +x586 >= -0.4823529411764706 +x586 >= -0.1 +x587 <= 0.1 +x587 <= 1.0 x587 >= -0.1 x587 >= 0.0 -x587 <= 1.0 -x587 <= 0.1 +x588 <= 0.1 +x588 <= 1.0 x588 >= -0.1 x588 >= 0.0 -x588 <= 1.0 -x588 <= 0.1 +x589 <= 0.1 +x589 <= 1.0 x589 >= -0.1 x589 >= 0.0 -x589 <= 1.0 -x589 <= 0.1 +x590 <= 0.1 +x590 <= 1.0 x590 >= -0.1 x590 >= 0.0 -x590 <= 1.0 -x590 <= 0.1 +x591 <= 0.1 +x591 <= 1.0 x591 >= -0.1 x591 >= 0.0 -x591 <= 1.0 -x591 <= 0.1 +x592 <= 0.1 +x592 <= 1.0 x592 >= -0.1 x592 >= 0.0 -x592 <= 1.0 -x592 <= 0.1 +x593 <= 0.1 +x593 <= 1.0 x593 >= -0.1 x593 >= 0.0 -x593 <= 1.0 -x593 <= 0.1 +x594 <= 0.1 +x594 <= 1.0 x594 >= -0.1 x594 >= 0.0 -x594 <= 1.0 -x594 <= 0.1 +x595 <= 0.1 +x595 <= 1.0 x595 >= -0.1 x595 >= 0.0 -x595 <= 1.0 -x595 <= 0.1 -x596 >= 0.0 -x596 >= 0.5823529411764706 -x596 <= 1.0 -x596 <= 0.7823529411764706 -x597 >= 0.0 -x597 >= 0.8921568627450981 -x597 <= 1.0921568627450982 -x597 <= 1.0 -x598 >= 0.0 -x598 >= 0.8921568627450981 -x598 <= 1.0921568627450982 -x598 <= 1.0 +x596 <= 0.1 +x596 <= 0.3176470588235294 +x596 >= -0.6823529411764706 +x596 >= -0.1 +x597 <= 0.007843137254901933 +x597 <= 0.1 +x597 >= -0.9921568627450981 +x597 >= -0.1 +x598 <= 0.5568627450980392 +x598 <= 0.6490196078431373 +x598 >= -0.44313725490196076 +x598 >= 0.4490196078431373 +x599 <= 1.0 +x599 <= 1.0921568627450982 x599 >= 0.0 x599 >= 0.8921568627450981 -x599 <= 1.0921568627450982 -x599 <= 1.0 -x600 >= 0.0 -x600 >= 0.8921568627450981 -x600 <= 1.0921568627450982 -x600 <= 1.0 -x601 >= 0.0 -x601 >= 0.8921568627450981 -x601 <= 1.0921568627450982 -x601 <= 1.0 -x602 >= 0.0 -x602 >= 0.8921568627450981 -x602 <= 1.0921568627450982 -x602 <= 1.0 -x603 >= 0.0 -x603 >= 0.8921568627450981 -x603 <= 1.0921568627450982 -x603 <= 1.0 -x604 >= 0.0 -x604 >= 0.8921568627450981 -x604 <= 1.0921568627450982 -x604 <= 1.0 -x605 >= 0.0 -x605 >= 0.8921568627450981 -x605 <= 1.0921568627450982 -x605 <= 1.0 +x600 <= 0.8156862745098039 +x600 <= 0.907843137254902 +x600 >= -0.1843137254901961 +x600 >= 0.707843137254902 +x601 <= 0.031372549019607815 +x601 <= 0.12352941176470589 +x601 >= -0.9686274509803922 +x601 >= -0.07647058823529412 +x602 <= 0.007843137254901933 +x602 <= 0.1 +x602 >= -0.9921568627450981 +x602 >= -0.1 +x603 <= 0.0549019607843137 +x603 <= 0.14705882352941177 +x603 >= -0.9450980392156862 +x603 >= -0.052941176470588235 +x604 <= 0.1333333333333333 +x604 <= 0.22549019607843138 +x604 >= -0.8666666666666667 +x604 >= 0.025490196078431372 +x605 <= 0.8313725490196078 +x605 <= 0.9235294117647058 +x605 >= -0.16862745098039222 +x605 >= 0.7235294117647059 +x606 <= 1.0 +x606 <= 1.0921568627450982 x606 >= 0.0 x606 >= 0.8921568627450981 -x606 <= 1.0921568627450982 -x606 <= 1.0 -x607 >= 0.0 -x607 >= 0.8921568627450981 -x607 <= 1.0921568627450982 -x607 <= 1.0 -x608 >= 0.0 -x608 >= 0.8764705882352941 -x608 <= 1.076470588235294 -x608 <= 1.0 -x609 >= 0.0 -x609 >= 0.8686274509803922 -x609 <= 1.0686274509803921 -x609 <= 1.0 -x610 >= 0.0 -x610 >= 0.8686274509803922 -x610 <= 1.0686274509803921 -x610 <= 1.0 -x611 >= 0.0 -x611 >= 0.5627450980392157 -x611 <= 1.0 -x611 <= 0.7627450980392156 -x612 >= 0.0 -x612 >= 0.3588235294117647 -x612 <= 1.0 -x612 <= 0.5588235294117647 -x613 >= 0.0 -x613 >= 0.3588235294117647 -x613 <= 1.0 -x613 <= 0.5588235294117647 -x614 >= 0.0 -x614 >= 0.12352941176470589 -x614 <= 1.0 -x614 <= 0.3235294117647059 +x607 <= 0.988235294117647 +x607 <= 1.080392156862745 +x607 >= -0.01176470588235301 +x607 >= 0.8803921568627451 +x608 <= 0.2274509803921569 +x608 <= 0.30392156862745096 +x608 >= -0.7725490196078431 +x608 >= 0.10392156862745097 +x609 <= 0.03137254901960784 +x609 <= 0.1 +x609 >= -0.9686274509803922 +x609 >= -0.1 +x610 <= 0.03137254901960784 +x610 <= 0.1 +x610 >= -0.9686274509803922 +x610 >= -0.1 +x611 <= 0.1 +x611 <= 0.33725490196078434 +x611 >= -0.6627450980392157 +x611 >= -0.1 +x612 <= 0.1 +x612 <= 0.5411764705882354 +x612 >= -0.4588235294117647 +x612 >= -0.1 +x613 <= 0.1 +x613 <= 0.5411764705882354 +x613 >= -0.4588235294117647 +x613 >= -0.1 +x614 <= 0.1 +x614 <= 0.7764705882352941 +x614 >= -0.2235294117647059 +x614 >= -0.1 +x615 <= 0.1 +x615 <= 1.0 x615 >= -0.1 x615 >= 0.0 -x615 <= 1.0 -x615 <= 0.1 +x616 <= 0.1 +x616 <= 1.0 x616 >= -0.1 x616 >= 0.0 -x616 <= 1.0 -x616 <= 0.1 +x617 <= 0.1 +x617 <= 1.0 x617 >= -0.1 x617 >= 0.0 -x617 <= 1.0 -x617 <= 0.1 +x618 <= 0.1 +x618 <= 1.0 x618 >= -0.1 x618 >= 0.0 -x618 <= 1.0 -x618 <= 0.1 +x619 <= 0.1 +x619 <= 1.0 x619 >= -0.1 x619 >= 0.0 -x619 <= 1.0 -x619 <= 0.1 +x620 <= 0.1 +x620 <= 1.0 x620 >= -0.1 x620 >= 0.0 -x620 <= 1.0 -x620 <= 0.1 +x621 <= 0.1 +x621 <= 1.0 x621 >= -0.1 x621 >= 0.0 -x621 <= 1.0 -x621 <= 0.1 +x622 <= 0.1 +x622 <= 1.0 x622 >= -0.1 x622 >= 0.0 -x622 <= 1.0 -x622 <= 0.1 +x623 <= 0.1 +x623 <= 1.0 x623 >= -0.1 x623 >= 0.0 -x623 <= 1.0 -x623 <= 0.1 +x624 <= 0.1 +x624 <= 1.0 x624 >= -0.1 x624 >= 0.0 -x624 <= 1.0 -x624 <= 0.1 -x625 >= 0.0 -x625 >= 0.36274509803921573 -x625 <= 1.0 -x625 <= 0.5627450980392157 -x626 >= 0.0 -x626 >= 0.3823529411764706 -x626 <= 1.0 -x626 <= 0.5823529411764706 -x627 >= 0.0 -x627 >= 0.3823529411764706 -x627 <= 1.0 -x627 <= 0.5823529411764706 -x628 >= 0.0 -x628 >= 0.3823529411764706 -x628 <= 1.0 -x628 <= 0.5823529411764706 -x629 >= 0.0 -x629 >= 0.5509803921568628 -x629 <= 1.0 -x629 <= 0.7509803921568627 -x630 >= 0.0 -x630 >= 0.8921568627450981 -x630 <= 1.0921568627450982 -x630 <= 1.0 -x631 >= 0.0 -x631 >= 0.8921568627450981 -x631 <= 1.0921568627450982 -x631 <= 1.0 +x625 <= 0.1 +x625 <= 0.5372549019607843 +x625 >= -0.4627450980392157 +x625 >= -0.1 +x626 <= 0.5784313725490197 +x626 <= 0.996078431372549 +x626 >= -0.0039215686274509665 +x626 >= 0.37843137254901965 +x627 <= 1.0921568627450982 +x627 <= 1.5098039215686274 +x627 >= 0.5098039215686274 +x627 >= 0.8921568627450981 +x628 <= 1.0921568627450982 +x628 <= 1.5098039215686274 +x628 >= 0.5098039215686274 +x628 >= 0.8921568627450981 +x629 <= 0.7901960784313725 +x629 <= 1.0392156862745097 +x629 >= 0.039215686274509776 +x629 >= 0.5901960784313726 +x630 <= 0.5647058823529412 +x630 <= 0.6568627450980392 +x630 >= -0.43529411764705883 +x630 >= 0.45686274509803926 +x631 <= 0.8431372549019608 +x631 <= 0.9352941176470588 +x631 >= -0.1568627450980392 +x631 >= 0.7352941176470589 +x632 <= 1.0 +x632 <= 1.0921568627450982 x632 >= 0.0 x632 >= 0.8921568627450981 -x632 <= 1.0921568627450982 -x632 <= 1.0 -x633 >= 0.0 -x633 >= 0.5078431372549019 -x633 <= 1.0 -x633 <= 0.7078431372549019 -x634 >= 0.0 -x634 >= 0.3823529411764706 -x634 <= 1.0 -x634 <= 0.5823529411764706 -x635 >= 0.0 -x635 >= 0.3823529411764706 -x635 <= 1.0 -x635 <= 0.5823529411764706 -x636 >= 0.0 -x636 >= 0.06078431372549021 -x636 <= 1.0 -x636 <= 0.2607843137254902 +x633 <= 1.0921568627450982 +x633 <= 1.384313725490196 +x633 >= 0.38431372549019616 +x633 >= 0.8921568627450981 +x634 <= 1.0921568627450982 +x634 <= 1.5098039215686274 +x634 >= 0.5098039215686274 +x634 >= 0.8921568627450981 +x635 <= 0.7627450980392156 +x635 <= 1.1803921568627451 +x635 >= 0.18039215686274507 +x635 >= 0.5627450980392157 +x636 <= 0.1 +x636 <= 0.8392156862745098 +x636 >= -0.1607843137254902 +x636 >= -0.1 +x637 <= 0.1 +x637 <= 1.0 x637 >= -0.1 x637 >= 0.0 -x637 <= 1.0 -x637 <= 0.1 +x638 <= 0.1 +x638 <= 1.0 x638 >= -0.1 x638 >= 0.0 -x638 <= 1.0 -x638 <= 0.1 +x639 <= 0.1 +x639 <= 1.0 x639 >= -0.1 x639 >= 0.0 -x639 <= 1.0 -x639 <= 0.1 +x640 <= 0.1 +x640 <= 1.0 x640 >= -0.1 x640 >= 0.0 -x640 <= 1.0 -x640 <= 0.1 +x641 <= 0.1 +x641 <= 1.0 x641 >= -0.1 x641 >= 0.0 -x641 <= 1.0 -x641 <= 0.1 +x642 <= 0.1 +x642 <= 1.0 x642 >= -0.1 x642 >= 0.0 -x642 <= 1.0 -x642 <= 0.1 +x643 <= 0.1 +x643 <= 1.0 x643 >= -0.1 x643 >= 0.0 -x643 <= 1.0 -x643 <= 0.1 +x644 <= 0.1 +x644 <= 1.0 x644 >= -0.1 x644 >= 0.0 -x644 <= 1.0 -x644 <= 0.1 +x645 <= 0.1 +x645 <= 1.0 x645 >= -0.1 x645 >= 0.0 -x645 <= 1.0 -x645 <= 0.1 +x646 <= 0.1 +x646 <= 1.0 x646 >= -0.1 x646 >= 0.0 -x646 <= 1.0 -x646 <= 0.1 +x647 <= 0.1 +x647 <= 1.0 x647 >= -0.1 x647 >= 0.0 -x647 <= 1.0 -x647 <= 0.1 +x648 <= 0.1 +x648 <= 1.0 x648 >= -0.1 x648 >= 0.0 -x648 <= 1.0 -x648 <= 0.1 +x649 <= 0.1 +x649 <= 1.0 x649 >= -0.1 x649 >= 0.0 -x649 <= 1.0 -x649 <= 0.1 +x650 <= 0.1 +x650 <= 1.0 x650 >= -0.1 x650 >= 0.0 -x650 <= 1.0 -x650 <= 0.1 +x651 <= 0.1 +x651 <= 1.0 x651 >= -0.1 x651 >= 0.0 -x651 <= 1.0 -x651 <= 0.1 +x652 <= 0.1 +x652 <= 1.0 x652 >= -0.1 x652 >= 0.0 -x652 <= 1.0 -x652 <= 0.1 +x653 <= 0.1 +x653 <= 1.0 x653 >= -0.1 x653 >= 0.0 -x653 <= 1.0 -x653 <= 0.1 -x654 >= -0.1 -x654 >= 0.0 -x654 <= 1.0 -x654 <= 0.1 -x655 >= -0.1 -x655 >= 0.0 -x655 <= 1.0 -x655 <= 0.1 -x656 >= -0.1 -x656 >= 0.0 -x656 <= 1.0 -x656 <= 0.1 -x657 >= -0.1 -x657 >= 0.0 -x657 <= 1.0 -x657 <= 0.1 -x658 >= -0.1 -x658 >= 0.0 -x658 <= 1.0 -x658 <= 0.1 -x659 >= -0.1 -x659 >= 0.0 -x659 <= 1.0 -x659 <= 0.1 -x660 >= -0.1 -x660 >= 0.0 -x660 <= 1.0 -x660 <= 0.1 -x661 >= -0.1 -x661 >= 0.0 -x661 <= 1.0 -x661 <= 0.1 -x662 >= -0.1 -x662 >= 0.0 -x662 <= 1.0 -x662 <= 0.1 +x654 <= 0.21764705882352942 +x654 <= 1.1176470588235294 +x654 >= 0.01764705882352941 +x654 >= 0.11764705882352941 +x655 <= 0.9549019607843137 +x655 <= 1.8549019607843138 +x655 >= 0.7549019607843137 +x655 >= 0.8549019607843137 +x656 <= 1.0921568627450982 +x656 <= 1.992156862745098 +x656 >= 0.8921568627450981 +x656 >= 0.9921568627450981 +x657 <= 1.0921568627450982 +x657 <= 1.992156862745098 +x657 >= 0.8921568627450981 +x657 >= 0.9921568627450981 +x658 <= 1.0921568627450982 +x658 <= 1.992156862745098 +x658 >= 0.8921568627450981 +x658 >= 0.9921568627450981 +x659 <= 1.0921568627450982 +x659 <= 1.992156862745098 +x659 >= 0.8921568627450981 +x659 >= 0.9921568627450981 +x660 <= 1.0921568627450982 +x660 <= 1.992156862745098 +x660 >= 0.8921568627450981 +x660 >= 0.9921568627450981 +x661 <= 1.0921568627450982 +x661 <= 1.992156862745098 +x661 >= 0.8921568627450981 +x661 >= 0.9921568627450981 +x662 <= 0.7627450980392156 +x662 <= 1.6627450980392156 +x662 >= 0.5627450980392157 +x662 >= 0.6627450980392157 +x663 <= 0.1 +x663 <= 1.0 x663 >= -0.1 x663 >= 0.0 -x663 <= 1.0 -x663 <= 0.1 +x664 <= 0.1 +x664 <= 1.0 x664 >= -0.1 x664 >= 0.0 -x664 <= 1.0 -x664 <= 0.1 +x665 <= 0.1 +x665 <= 1.0 x665 >= -0.1 x665 >= 0.0 -x665 <= 1.0 -x665 <= 0.1 +x666 <= 0.1 +x666 <= 1.0 x666 >= -0.1 x666 >= 0.0 -x666 <= 1.0 -x666 <= 0.1 +x667 <= 0.1 +x667 <= 1.0 x667 >= -0.1 x667 >= 0.0 -x667 <= 1.0 -x667 <= 0.1 +x668 <= 0.1 +x668 <= 1.0 x668 >= -0.1 x668 >= 0.0 -x668 <= 1.0 -x668 <= 0.1 +x669 <= 0.1 +x669 <= 1.0 x669 >= -0.1 x669 >= 0.0 -x669 <= 1.0 -x669 <= 0.1 +x670 <= 0.1 +x670 <= 1.0 x670 >= -0.1 x670 >= 0.0 -x670 <= 1.0 -x670 <= 0.1 +x671 <= 0.1 +x671 <= 1.0 x671 >= -0.1 x671 >= 0.0 -x671 <= 1.0 -x671 <= 0.1 +x672 <= 0.1 +x672 <= 1.0 x672 >= -0.1 x672 >= 0.0 -x672 <= 1.0 -x672 <= 0.1 +x673 <= 0.1 +x673 <= 1.0 x673 >= -0.1 x673 >= 0.0 -x673 <= 1.0 -x673 <= 0.1 +x674 <= 0.1 +x674 <= 1.0 x674 >= -0.1 x674 >= 0.0 -x674 <= 1.0 -x674 <= 0.1 +x675 <= 0.1 +x675 <= 1.0 x675 >= -0.1 x675 >= 0.0 -x675 <= 1.0 -x675 <= 0.1 +x676 <= 0.1 +x676 <= 1.0 x676 >= -0.1 x676 >= 0.0 -x676 <= 1.0 -x676 <= 0.1 +x677 <= 0.1 +x677 <= 1.0 x677 >= -0.1 x677 >= 0.0 -x677 <= 1.0 -x677 <= 0.1 +x678 <= 0.1 +x678 <= 1.0 x678 >= -0.1 x678 >= 0.0 -x678 <= 1.0 -x678 <= 0.1 +x679 <= 0.1 +x679 <= 1.0 x679 >= -0.1 x679 >= 0.0 -x679 <= 1.0 -x679 <= 0.1 +x680 <= 0.1 +x680 <= 1.0 x680 >= -0.1 x680 >= 0.0 -x680 <= 1.0 -x680 <= 0.1 +x681 <= 0.1 +x681 <= 1.0 x681 >= -0.1 x681 >= 0.0 -x681 <= 1.0 -x681 <= 0.1 +x682 <= 0.1 +x682 <= 1.0 x682 >= -0.1 x682 >= 0.0 -x682 <= 1.0 -x682 <= 0.1 -x683 >= -0.1 -x683 >= 0.0 -x683 <= 1.0 -x683 <= 0.1 -x684 >= -0.1 -x684 >= 0.0 -x684 <= 1.0 -x684 <= 0.1 -x685 >= -0.1 -x685 >= 0.0 -x685 <= 1.0 -x685 <= 0.1 -x686 >= -0.1 -x686 >= 0.0 -x686 <= 1.0 -x686 <= 0.1 -x687 >= -0.1 -x687 >= 0.0 -x687 <= 1.0 -x687 <= 0.1 -x688 >= -0.1 -x688 >= 0.0 -x688 <= 1.0 -x688 <= 0.1 -x689 >= -0.1 -x689 >= 0.0 -x689 <= 1.0 -x689 <= 0.1 +x683 <= 0.46470588235294114 +x683 <= 1.3647058823529412 +x683 >= 0.2647058823529412 +x683 >= 0.36470588235294116 +x684 <= 0.6882352941176471 +x684 <= 1.5882352941176472 +x684 >= 0.4882352941176471 +x684 >= 0.5882352941176471 +x685 <= 1.1 +x685 <= 2.0 +x685 >= 0.9 +x685 >= 1.0 +x686 <= 1.1 +x686 <= 2.0 +x686 >= 0.9 +x686 >= 1.0 +x687 <= 0.7705882352941176 +x687 <= 1.6705882352941175 +x687 >= 0.5705882352941176 +x687 >= 0.6705882352941176 +x688 <= 0.5901960784313726 +x688 <= 1.4901960784313726 +x688 >= 0.39019607843137255 +x688 >= 0.49019607843137253 +x689 <= 0.5549019607843138 +x689 <= 1.4549019607843137 +x689 >= 0.35490196078431374 +x689 >= 0.4549019607843137 +x690 <= 0.1 +x690 <= 1.0 x690 >= -0.1 x690 >= 0.0 -x690 <= 1.0 -x690 <= 0.1 +x691 <= 0.1 +x691 <= 1.0 x691 >= -0.1 x691 >= 0.0 -x691 <= 1.0 -x691 <= 0.1 +x692 <= 0.1 +x692 <= 1.0 x692 >= -0.1 x692 >= 0.0 -x692 <= 1.0 -x692 <= 0.1 +x693 <= 0.1 +x693 <= 1.0 x693 >= -0.1 x693 >= 0.0 -x693 <= 1.0 -x693 <= 0.1 +x694 <= 0.1 +x694 <= 1.0 x694 >= -0.1 x694 >= 0.0 -x694 <= 1.0 -x694 <= 0.1 +x695 <= 0.1 +x695 <= 1.0 x695 >= -0.1 x695 >= 0.0 -x695 <= 1.0 -x695 <= 0.1 +x696 <= 0.1 +x696 <= 1.0 x696 >= -0.1 x696 >= 0.0 -x696 <= 1.0 -x696 <= 0.1 +x697 <= 0.1 +x697 <= 1.0 x697 >= -0.1 x697 >= 0.0 -x697 <= 1.0 -x697 <= 0.1 +x698 <= 0.1 +x698 <= 1.0 x698 >= -0.1 x698 >= 0.0 -x698 <= 1.0 -x698 <= 0.1 +x699 <= 0.1 +x699 <= 1.0 x699 >= -0.1 x699 >= 0.0 -x699 <= 1.0 -x699 <= 0.1 +x700 <= 0.1 +x700 <= 1.0 x700 >= -0.1 x700 >= 0.0 -x700 <= 1.0 -x700 <= 0.1 +x701 <= 0.1 +x701 <= 1.0 x701 >= -0.1 x701 >= 0.0 -x701 <= 1.0 -x701 <= 0.1 +x702 <= 0.1 +x702 <= 1.0 x702 >= -0.1 x702 >= 0.0 -x702 <= 1.0 -x702 <= 0.1 +x703 <= 0.1 +x703 <= 1.0 x703 >= -0.1 x703 >= 0.0 -x703 <= 1.0 -x703 <= 0.1 +x704 <= 0.1 +x704 <= 1.0 x704 >= -0.1 x704 >= 0.0 -x704 <= 1.0 -x704 <= 0.1 +x705 <= 0.1 +x705 <= 1.0 x705 >= -0.1 x705 >= 0.0 -x705 <= 1.0 -x705 <= 0.1 +x706 <= 0.1 +x706 <= 1.0 x706 >= -0.1 x706 >= 0.0 -x706 <= 1.0 -x706 <= 0.1 +x707 <= 0.1 +x707 <= 1.0 x707 >= -0.1 x707 >= 0.0 -x707 <= 1.0 -x707 <= 0.1 +x708 <= 0.1 +x708 <= 1.0 x708 >= -0.1 x708 >= 0.0 -x708 <= 1.0 -x708 <= 0.1 +x709 <= 0.1 +x709 <= 1.0 x709 >= -0.1 x709 >= 0.0 -x709 <= 1.0 -x709 <= 0.1 +x710 <= 0.1 +x710 <= 1.0 x710 >= -0.1 x710 >= 0.0 -x710 <= 1.0 -x710 <= 0.1 +x711 <= 0.1 +x711 <= 1.0 x711 >= -0.1 x711 >= 0.0 -x711 <= 1.0 -x711 <= 0.1 +x712 <= 0.1 +x712 <= 1.0 x712 >= -0.1 x712 >= 0.0 -x712 <= 1.0 -x712 <= 0.1 +x713 <= 0.1 +x713 <= 1.0 x713 >= -0.1 x713 >= 0.0 -x713 <= 1.0 -x713 <= 0.1 +x714 <= 0.1 +x714 <= 1.0 x714 >= -0.1 x714 >= 0.0 -x714 <= 1.0 -x714 <= 0.1 +x715 <= 0.1 +x715 <= 1.0 x715 >= -0.1 x715 >= 0.0 -x715 <= 1.0 -x715 <= 0.1 +x716 <= 0.1 +x716 <= 1.0 x716 >= -0.1 x716 >= 0.0 -x716 <= 1.0 -x716 <= 0.1 +x717 <= 0.1 +x717 <= 1.0 x717 >= -0.1 x717 >= 0.0 -x717 <= 1.0 -x717 <= 0.1 +x718 <= 0.1 +x718 <= 1.0 x718 >= -0.1 x718 >= 0.0 -x718 <= 1.0 -x718 <= 0.1 +x719 <= 0.1 +x719 <= 1.0 x719 >= -0.1 x719 >= 0.0 -x719 <= 1.0 -x719 <= 0.1 +x720 <= 0.1 +x720 <= 1.0 x720 >= -0.1 x720 >= 0.0 -x720 <= 1.0 -x720 <= 0.1 +x721 <= 0.1 +x721 <= 1.0 x721 >= -0.1 x721 >= 0.0 -x721 <= 1.0 -x721 <= 0.1 +x722 <= 0.1 +x722 <= 1.0 x722 >= -0.1 x722 >= 0.0 -x722 <= 1.0 -x722 <= 0.1 +x723 <= 0.1 +x723 <= 1.0 x723 >= -0.1 x723 >= 0.0 -x723 <= 1.0 -x723 <= 0.1 +x724 <= 0.1 +x724 <= 1.0 x724 >= -0.1 x724 >= 0.0 -x724 <= 1.0 -x724 <= 0.1 +x725 <= 0.1 +x725 <= 1.0 x725 >= -0.1 x725 >= 0.0 -x725 <= 1.0 -x725 <= 0.1 +x726 <= 0.1 +x726 <= 1.0 x726 >= -0.1 x726 >= 0.0 -x726 <= 1.0 -x726 <= 0.1 +x727 <= 0.1 +x727 <= 1.0 x727 >= -0.1 x727 >= 0.0 -x727 <= 1.0 -x727 <= 0.1 +x728 <= 0.1 +x728 <= 1.0 x728 >= -0.1 x728 >= 0.0 -x728 <= 1.0 -x728 <= 0.1 +x729 <= 0.1 +x729 <= 1.0 x729 >= -0.1 x729 >= 0.0 -x729 <= 1.0 -x729 <= 0.1 +x730 <= 0.1 +x730 <= 1.0 x730 >= -0.1 x730 >= 0.0 -x730 <= 1.0 -x730 <= 0.1 +x731 <= 0.1 +x731 <= 1.0 x731 >= -0.1 x731 >= 0.0 -x731 <= 1.0 -x731 <= 0.1 +x732 <= 0.1 +x732 <= 1.0 x732 >= -0.1 x732 >= 0.0 -x732 <= 1.0 -x732 <= 0.1 +x733 <= 0.1 +x733 <= 1.0 x733 >= -0.1 x733 >= 0.0 -x733 <= 1.0 -x733 <= 0.1 +x734 <= 0.1 +x734 <= 1.0 x734 >= -0.1 x734 >= 0.0 -x734 <= 1.0 -x734 <= 0.1 +x735 <= 0.1 +x735 <= 1.0 x735 >= -0.1 x735 >= 0.0 -x735 <= 1.0 -x735 <= 0.1 +x736 <= 0.1 +x736 <= 1.0 x736 >= -0.1 x736 >= 0.0 -x736 <= 1.0 -x736 <= 0.1 +x737 <= 0.1 +x737 <= 1.0 x737 >= -0.1 x737 >= 0.0 -x737 <= 1.0 -x737 <= 0.1 +x738 <= 0.1 +x738 <= 1.0 x738 >= -0.1 x738 >= 0.0 -x738 <= 1.0 -x738 <= 0.1 +x739 <= 0.1 +x739 <= 1.0 x739 >= -0.1 x739 >= 0.0 -x739 <= 1.0 -x739 <= 0.1 +x740 <= 0.1 +x740 <= 1.0 x740 >= -0.1 x740 >= 0.0 -x740 <= 1.0 -x740 <= 0.1 +x741 <= 0.1 +x741 <= 1.0 x741 >= -0.1 x741 >= 0.0 -x741 <= 1.0 -x741 <= 0.1 +x742 <= 0.1 +x742 <= 1.0 x742 >= -0.1 x742 >= 0.0 -x742 <= 1.0 -x742 <= 0.1 +x743 <= 0.1 +x743 <= 1.0 x743 >= -0.1 x743 >= 0.0 -x743 <= 1.0 -x743 <= 0.1 +x744 <= 0.1 +x744 <= 1.0 x744 >= -0.1 x744 >= 0.0 -x744 <= 1.0 -x744 <= 0.1 +x745 <= 0.1 +x745 <= 1.0 x745 >= -0.1 x745 >= 0.0 -x745 <= 1.0 -x745 <= 0.1 +x746 <= 0.1 +x746 <= 1.0 x746 >= -0.1 x746 >= 0.0 -x746 <= 1.0 -x746 <= 0.1 +x747 <= 0.1 +x747 <= 1.0 x747 >= -0.1 x747 >= 0.0 -x747 <= 1.0 -x747 <= 0.1 +x748 <= 0.1 +x748 <= 1.0 x748 >= -0.1 x748 >= 0.0 -x748 <= 1.0 -x748 <= 0.1 +x749 <= 0.1 +x749 <= 1.0 x749 >= -0.1 x749 >= 0.0 -x749 <= 1.0 -x749 <= 0.1 +x750 <= 0.1 +x750 <= 1.0 x750 >= -0.1 x750 >= 0.0 -x750 <= 1.0 -x750 <= 0.1 +x751 <= 0.1 +x751 <= 1.0 x751 >= -0.1 x751 >= 0.0 -x751 <= 1.0 -x751 <= 0.1 +x752 <= 0.1 +x752 <= 1.0 x752 >= -0.1 x752 >= 0.0 -x752 <= 1.0 -x752 <= 0.1 +x753 <= 0.1 +x753 <= 1.0 x753 >= -0.1 x753 >= 0.0 -x753 <= 1.0 -x753 <= 0.1 +x754 <= 0.1 +x754 <= 1.0 x754 >= -0.1 x754 >= 0.0 -x754 <= 1.0 -x754 <= 0.1 +x755 <= 0.1 +x755 <= 1.0 x755 >= -0.1 x755 >= 0.0 -x755 <= 1.0 -x755 <= 0.1 +x756 <= 0.1 +x756 <= 1.0 x756 >= -0.1 x756 >= 0.0 -x756 <= 1.0 -x756 <= 0.1 +x757 <= 0.1 +x757 <= 1.0 x757 >= -0.1 x757 >= 0.0 -x757 <= 1.0 -x757 <= 0.1 +x758 <= 0.1 +x758 <= 1.0 x758 >= -0.1 x758 >= 0.0 -x758 <= 1.0 -x758 <= 0.1 +x759 <= 0.1 +x759 <= 1.0 x759 >= -0.1 x759 >= 0.0 -x759 <= 1.0 -x759 <= 0.1 +x760 <= 0.1 +x760 <= 1.0 x760 >= -0.1 x760 >= 0.0 -x760 <= 1.0 -x760 <= 0.1 +x761 <= 0.1 +x761 <= 1.0 x761 >= -0.1 x761 >= 0.0 -x761 <= 1.0 -x761 <= 0.1 +x762 <= 0.1 +x762 <= 1.0 x762 >= -0.1 x762 >= 0.0 -x762 <= 1.0 -x762 <= 0.1 +x763 <= 0.1 +x763 <= 1.0 x763 >= -0.1 x763 >= 0.0 -x763 <= 1.0 -x763 <= 0.1 +x764 <= 0.1 +x764 <= 1.0 x764 >= -0.1 x764 >= 0.0 -x764 <= 1.0 -x764 <= 0.1 +x765 <= 0.1 +x765 <= 1.0 x765 >= -0.1 x765 >= 0.0 -x765 <= 1.0 -x765 <= 0.1 +x766 <= 0.1 +x766 <= 1.0 x766 >= -0.1 x766 >= 0.0 -x766 <= 1.0 -x766 <= 0.1 +x767 <= 0.1 +x767 <= 1.0 x767 >= -0.1 x767 >= 0.0 -x767 <= 1.0 -x767 <= 0.1 +x768 <= 0.1 +x768 <= 1.0 x768 >= -0.1 x768 >= 0.0 -x768 <= 1.0 -x768 <= 0.1 +x769 <= 0.1 +x769 <= 1.0 x769 >= -0.1 x769 >= 0.0 -x769 <= 1.0 -x769 <= 0.1 +x770 <= 0.1 +x770 <= 1.0 x770 >= -0.1 x770 >= 0.0 -x770 <= 1.0 -x770 <= 0.1 +x771 <= 0.1 +x771 <= 1.0 x771 >= -0.1 x771 >= 0.0 -x771 <= 1.0 -x771 <= 0.1 +x772 <= 0.1 +x772 <= 1.0 x772 >= -0.1 x772 >= 0.0 -x772 <= 1.0 -x772 <= 0.1 +x773 <= 0.1 +x773 <= 1.0 x773 >= -0.1 x773 >= 0.0 -x773 <= 1.0 -x773 <= 0.1 +x774 <= 0.1 +x774 <= 1.0 x774 >= -0.1 x774 >= 0.0 -x774 <= 1.0 -x774 <= 0.1 +x775 <= 0.1 +x775 <= 1.0 x775 >= -0.1 x775 >= 0.0 -x775 <= 1.0 -x775 <= 0.1 +x776 <= 0.1 +x776 <= 1.0 x776 >= -0.1 x776 >= 0.0 -x776 <= 1.0 -x776 <= 0.1 +x777 <= 0.1 +x777 <= 1.0 x777 >= -0.1 x777 >= 0.0 -x777 <= 1.0 -x777 <= 0.1 +x778 <= 0.1 +x778 <= 1.0 x778 >= -0.1 x778 >= 0.0 -x778 <= 1.0 -x778 <= 0.1 +x779 <= 0.1 +x779 <= 1.0 x779 >= -0.1 x779 >= 0.0 -x779 <= 1.0 -x779 <= 0.1 +x780 <= 0.1 +x780 <= 1.0 x780 >= -0.1 x780 >= 0.0 -x780 <= 1.0 -x780 <= 0.1 +x781 <= 0.1 +x781 <= 1.0 x781 >= -0.1 x781 >= 0.0 -x781 <= 1.0 -x781 <= 0.1 +x782 <= 0.1 +x782 <= 1.0 x782 >= -0.1 x782 >= 0.0 -x782 <= 1.0 -x782 <= 0.1 -x783 >= -0.1 -x783 >= 0.0 -x783 <= 1.0 x783 <= 0.1 -+y2 -y9 <= 0.0 \ No newline at end of file +x783 <= 1.0 +x783 >= -0.1 +x783 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1.vcl-plan.golden b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1.vcl-plan.golden index 7ca830fba..fa51d0ab4 100644 --- a/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1.vcl-plan.golden +++ b/vehicle/tests/golden/compile/mnist-robustness/Marabou.queries/robust!1.vcl-plan.golden @@ -6,70 +6,22 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 - ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { - "dimensions": [ - 28, - 28 - ], - "constantValue": [ + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -447,31 +399,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -555,39 +507,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -663,43 +615,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -771,27 +723,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -799,19 +751,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -883,19 +835,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -911,19 +863,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -999,11 +951,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -1023,19 +975,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -1131,23 +1083,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -1239,23 +1191,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -1351,19 +1303,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -1459,23 +1411,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -1567,23 +1519,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -1679,19 +1631,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -1787,23 +1739,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -1895,23 +1847,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -2007,23 +1959,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -2119,19 +2071,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -2231,39 +2183,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -2271,39 +2223,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -2343,79 +2295,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -2455,79 +2407,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -2571,51 +2523,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -3207,593 +3159,13234 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + } + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 + ] } } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + ] + } + ], + "queryAddress": [ { "propertyName": "robust", "propertyIndices": [ 1 - ] + ], + "propertyID": 0 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 - ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { - "dimensions": [ - 28, - 28 - ], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 8194785204313373, - "denominator": 18014398509481984 - }, - { - "numerator": 8830587504648031, - "denominator": 18014398509481984 - }, - { - "numerator": 6040121853179253, - "denominator": 9007199254740992 - }, - { - "numerator": 1, - "denominator": 1 - }, - { - "numerator": 1, - "denominator": 1 - }, - { - "numerator": 5298352502788819, - "denominator": 9007199254740992 - }, - { - "numerator": 6569957103458135, - "denominator": 18014398509481984 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 - }, - { - "numerator": 0, - "denominator": 1 + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 28, + 28 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": -8194785204313373, + "denominator": 18014398509481984 + }, + { + "numerator": -8830587504648031, + "denominator": 18014398509481984 + }, + { + "numerator": -6040121853179253, + "denominator": 9007199254740992 + }, + { + "numerator": -1, + "denominator": 1 + }, + { + "numerator": -1, + "denominator": 1 + }, + { + "numerator": -5298352502788819, + "denominator": 9007199254740992 + }, + { + "numerator": -6569957103458135, + "denominator": 18014398509481984 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 + }, + { + "numerator": 0, + "denominator": 1 }, { "numerator": 0, @@ -3836,39 +16429,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -3944,43 +16537,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -4052,27 +16645,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -4080,19 +16673,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -4164,19 +16757,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -4192,19 +16785,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -4280,11 +16873,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -4304,19 +16897,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -4412,23 +17005,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -4520,23 +17113,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -4632,19 +17225,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -4740,23 +17333,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -4848,23 +17441,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -4960,19 +17553,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -5068,23 +17661,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -5176,23 +17769,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -5288,23 +17881,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -5400,19 +17993,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -5512,39 +18105,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -5552,39 +18145,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -5624,79 +18217,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -5736,79 +18329,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -5852,51 +18445,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -6488,150 +19081,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + } + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 3 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -7009,31 +32243,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -7117,39 +32351,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -7225,43 +32459,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -7333,27 +32567,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -7361,19 +32595,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -7445,19 +32679,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -7473,19 +32707,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -7561,11 +32795,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -7585,19 +32819,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -7693,23 +32927,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -7801,23 +33035,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -7913,19 +33147,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -8021,23 +33255,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -8129,23 +33363,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -8241,19 +33475,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -8349,23 +33583,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -8457,23 +33691,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -8569,23 +33803,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -8681,19 +33915,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -8793,39 +34027,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -8833,39 +34067,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -8905,79 +34139,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -9017,79 +34251,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -9133,51 +34367,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -9769,150 +35003,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 3 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 4 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -10290,31 +48165,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -10398,39 +48273,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -10506,43 +48381,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -10614,27 +48489,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -10642,19 +48517,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -10726,19 +48601,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -10754,19 +48629,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -10842,11 +48717,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -10866,19 +48741,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -10974,23 +48849,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -11082,23 +48957,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -11194,19 +49069,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -11302,23 +49177,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -11410,23 +49285,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -11522,19 +49397,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -11630,23 +49505,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -11738,23 +49613,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -11850,23 +49725,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -11962,19 +49837,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -12074,39 +49949,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -12114,39 +49989,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -12186,79 +50061,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -12298,79 +50173,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -12414,51 +50289,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -13050,150 +50925,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 4 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 5 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -13571,31 +64087,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -13679,39 +64195,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -13787,43 +64303,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -13895,27 +64411,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -13923,19 +64439,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -14007,19 +64523,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -14035,19 +64551,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -14123,11 +64639,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -14147,19 +64663,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -14255,23 +64771,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -14363,23 +64879,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -14475,19 +64991,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -14583,23 +65099,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -14691,23 +65207,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -14803,19 +65319,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -14911,23 +65427,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -15019,23 +65535,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -15131,23 +65647,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -15243,19 +65759,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -15355,39 +65871,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -15395,39 +65911,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -15467,79 +65983,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -15579,79 +66095,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -15695,51 +66211,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -16331,150 +66847,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 5 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 6 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -16852,31 +80009,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -16960,39 +80117,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -17068,43 +80225,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -17176,27 +80333,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -17204,19 +80361,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -17288,19 +80445,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -17316,19 +80473,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -17404,11 +80561,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -17428,19 +80585,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -17536,23 +80693,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -17644,23 +80801,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -17756,19 +80913,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -17864,23 +81021,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -17972,23 +81129,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -18084,19 +81241,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -18192,23 +81349,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -18300,23 +81457,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -18412,23 +81569,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -18524,19 +81681,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -18636,39 +81793,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -18676,39 +81833,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -18748,79 +81905,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -18860,79 +82017,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -18976,51 +82133,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -19612,150 +82769,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 6 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 7 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -20133,31 +95931,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -20241,39 +96039,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -20349,43 +96147,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -20457,27 +96255,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -20485,19 +96283,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -20569,19 +96367,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -20597,19 +96395,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -20685,11 +96483,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -20709,19 +96507,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -20817,23 +96615,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -20925,23 +96723,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -21037,19 +96835,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -21145,23 +96943,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -21253,23 +97051,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -21365,19 +97163,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -21473,23 +97271,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -21581,23 +97379,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -21693,23 +97491,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -21805,19 +97603,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -21917,39 +97715,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -21957,39 +97755,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -22029,79 +97827,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -22141,79 +97939,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -22257,51 +98055,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -22893,150 +98691,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 7 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 8 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -23414,31 +111853,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -23522,39 +111961,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -23630,43 +112069,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -23738,27 +112177,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -23766,19 +112205,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -23850,19 +112289,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -23878,19 +112317,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -23966,11 +112405,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -23990,19 +112429,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -24098,23 +112537,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -24206,23 +112645,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -24318,19 +112757,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -24426,23 +112865,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -24534,23 +112973,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -24646,19 +113085,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -24754,23 +113193,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -24862,23 +113301,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -24974,23 +113413,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -25086,19 +113525,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -25198,39 +113637,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -25238,39 +113677,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -25310,79 +113749,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -25422,79 +113861,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -25538,51 +113977,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -26174,150 +114613,12791 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] } - ] + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 8 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ - { - "propertyName": "robust", - "propertyIndices": [ - 1 - ] - }, - 9 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "pertubation", - "userVarDimensions": [ - 28, - 28 + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "classifier", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 ], - "unreducedUserVarName": "pertubation" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 28, 28 ], - "constantValue": [ + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -26695,31 +127775,31 @@ "denominator": 1 }, { - "numerator": 8194785204313373, + "numerator": -8194785204313373, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 18014398509481984 }, { - "numerator": 6040121853179253, + "numerator": -6040121853179253, "denominator": 9007199254740992 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 1, + "numerator": -1, "denominator": 1 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 6569957103458135, + "numerator": -6569957103458135, "denominator": 18014398509481984 }, { @@ -26803,39 +127883,39 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7700272304053083, + "numerator": -7700272304053083, "denominator": 9007199254740992 }, { - "numerator": 4238682002231055, + "numerator": -4238682002231055, "denominator": 36028797018963968 }, { @@ -26911,43 +127991,43 @@ "denominator": 1 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7523660553960123, + "numerator": -7523660553960123, "denominator": 9007199254740992 }, { - "numerator": 2507886851320041, + "numerator": -2507886851320041, "denominator": 4503599627370496 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { @@ -27019,27 +128099,27 @@ "denominator": 1 }, { - "numerator": 3673524401933581, + "numerator": -3673524401933581, "denominator": 18014398509481984 }, { - "numerator": 8830587504648031, + "numerator": -8830587504648031, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -27047,19 +128127,19 @@ "denominator": 1 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 36028797018963968 }, { - "numerator": 3638202051914989, + "numerator": -3638202051914989, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 4503599627370496 }, { @@ -27131,19 +128211,19 @@ "denominator": 1 }, { - "numerator": 5439641902863187, + "numerator": -5439641902863187, "denominator": 18014398509481984 }, { - "numerator": 8865909854666623, + "numerator": -8865909854666623, "denominator": 9007199254740992 }, { - "numerator": 3708846751952173, + "numerator": -3708846751952173, "denominator": 4503599627370496 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -27159,19 +128239,19 @@ "denominator": 1 }, { - "numerator": 8618653404536479, + "numerator": -8618653404536479, "denominator": 18014398509481984 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -27247,11 +128327,11 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 72057594037927936 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 36028797018963968 }, { @@ -27271,19 +128351,19 @@ "denominator": 1 }, { - "numerator": 3691185576942877, + "numerator": -3691185576942877, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 286994093901061, + "numerator": -286994093901061, "denominator": 1125899906842624 }, { @@ -27379,23 +128459,23 @@ "denominator": 1 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -27487,23 +128567,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 18014398509481984 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8159462854294781, + "numerator": -8159462854294781, "denominator": 9007199254740992 }, { - "numerator": 278163506396413, + "numerator": -278163506396413, "denominator": 1125899906842624 }, { @@ -27599,19 +128679,19 @@ "denominator": 1 }, { - "numerator": 282578800148737, + "numerator": -282578800148737, "denominator": 562949953421312 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2543209201338633, + "numerator": -2543209201338633, "denominator": 4503599627370496 }, { @@ -27707,23 +128787,23 @@ "denominator": 1 }, { - "numerator": 3108366801636107, + "numerator": -3108366801636107, "denominator": 4503599627370496 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 1404063413239037, + "numerator": -1404063413239037, "denominator": 2251799813685248 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -27815,23 +128895,23 @@ "denominator": 1 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8230107554331965, + "numerator": -8230107554331965, "denominator": 9007199254740992 }, { - "numerator": 2472564501301449, + "numerator": -2472564501301449, "denominator": 18014398509481984 }, { @@ -27927,19 +129007,19 @@ "denominator": 1 }, { - "numerator": 6993825303681241, + "numerator": -6993825303681241, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -28035,23 +129115,23 @@ "denominator": 1 }, { - "numerator": 1377571650725093, + "numerator": -1377571650725093, "denominator": 4503599627370496 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 834490519189239, + "numerator": -834490519189239, "denominator": 1125899906842624 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -28143,23 +129223,23 @@ "denominator": 1 }, { - "numerator": 5368997202826003, + "numerator": -5368997202826003, "denominator": 72057594037927936 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 2490225676310745, + "numerator": -2490225676310745, "denominator": 4503599627370496 }, { @@ -28255,23 +129335,23 @@ "denominator": 1 }, { - "numerator": 4733194902491345, + "numerator": -4733194902491345, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3055383276608219, + "numerator": -3055383276608219, "denominator": 4503599627370496 }, { - "numerator": 847736400446211, + "numerator": -847736400446211, "denominator": 18014398509481984 }, { @@ -28367,19 +129447,19 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 7064470003718425, + "numerator": -7064470003718425, "denominator": 72057594037927936 }, { @@ -28479,39 +129559,39 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 3037722101598923, + "numerator": -3037722101598923, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { @@ -28519,39 +129599,39 @@ "denominator": 1 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 72057594037927936 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 18014398509481984 }, { - "numerator": 5227707802751635, + "numerator": -5227707802751635, "denominator": 36028797018963968 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 5298352502788819, + "numerator": -5298352502788819, "denominator": 9007199254740992 }, { - "numerator": 2596192726366521, + "numerator": -2596192726366521, "denominator": 4503599627370496 }, { - "numerator": 1412894000743685, + "numerator": -1412894000743685, "denominator": 36028797018963968 }, { @@ -28591,79 +129671,79 @@ "denominator": 1 }, { - "numerator": 8759942804610847, + "numerator": -8759942804610847, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5934154803123477, + "numerator": -5934154803123477, "denominator": 9007199254740992 }, { - "numerator": 2525548026329337, + "numerator": -2525548026329337, "denominator": 4503599627370496 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { @@ -28703,79 +129783,79 @@ "denominator": 1 }, { - "numerator": 3073044451617515, + "numerator": -3073044451617515, "denominator": 4503599627370496 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 8795265154629439, + "numerator": -8795265154629439, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 8724620454592255, + "numerator": -8724620454592255, "denominator": 9007199254740992 }, { - "numerator": 5969477153142069, + "numerator": -5969477153142069, "denominator": 9007199254740992 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8265429904350557, + "numerator": -8265429904350557, "denominator": 18014398509481984 }, { - "numerator": 8053495804239005, + "numerator": -8053495804239005, "denominator": 36028797018963968 }, { @@ -28819,51 +129899,51 @@ "denominator": 1 }, { - "numerator": 4168037302193871, + "numerator": -4168037302193871, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5863510103086293, + "numerator": -5863510103086293, "denominator": 9007199254740992 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 139633664917247, + "numerator": -139633664917247, "denominator": 140737488355328 }, { - "numerator": 5474964252881779, + "numerator": -5474964252881779, "denominator": 9007199254740992 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 8689298104573663, + "numerator": -8689298104573663, "denominator": 18014398509481984 }, { - "numerator": 5792865403049109, + "numerator": -5792865403049109, "denominator": 36028797018963968 }, { @@ -29455,86 +130535,12775 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": -1, - "denominator": 1 + "tensorDims": [ + 28, + 28 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "pertubation", + "userTensorVarDimensions": [ + 28, + 28 + ] + } + }, + { + "numerator": 1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 28, - 28 - ], - "networkName": "classifier", - "inputOrOutput": "Input", - "application": 0 + ] } } + ] + } + ], + "queryAddress": [ + { + "propertyName": "robust", + "propertyIndices": [ + 1 + ], + "propertyID": 0 + }, + 9 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 27, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 27, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 26, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 25, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 24, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 23, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 22, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 21, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 20, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 19, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 18, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 17, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 16, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 15, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 14, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 13, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 12, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 11, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 10, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 8, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 7, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 6, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 10 - ], - "networkName": "classifier", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 5, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 5, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 4, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 3, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 2, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 27 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 26 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 25 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 24 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 23 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 22 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 21 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 20 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 19 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 18 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 17 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 16 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 15 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 14 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 13 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 12 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 11 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 10 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 28, + 28 + ], + "networkName": "classifier", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 9 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 8 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 7 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 6 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 5 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 4 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 10 + ], + "networkName": "classifier", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 10 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 28, - 28 - ], - "baseType": [] - } - }, + "networkEntries": [ + { "metaNetworkEntryName": "classifier", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 10 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 28, + 28 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/monotonicity/Agda.agda.golden b/vehicle/tests/golden/compile/monotonicity/Agda.agda.golden index 25307ed0f..06e27e95d 100644 --- a/vehicle/tests/golden/compile/monotonicity/Agda.agda.golden +++ b/vehicle/tests/golden/compile/monotonicity/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/monotonicity/Marabou.err.golden b/vehicle/tests/golden/compile/monotonicity/Marabou.err.golden index 86f1ed628..6a3c44036 100644 --- a/vehicle/tests/golden/compile/monotonicity/Marabou.err.golden +++ b/vehicle/tests/golden/compile/monotonicity/Marabou.err.golden @@ -1,14 +1,13 @@  -Warning: While compiling property 'monotonic', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - f₁[input]!0 - no constraints - - -Warning: While compiling property 'monotonic', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'monotonic', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'monotonic', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound + f₁[input]!0 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic-query1.txt.golden b/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic-query1.txt.golden index d0f484bc4..b1c6990c0 100644 --- a/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic-query1.txt.golden +++ b/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x0 -x1 <= 0.0 -y0 +y1 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic.vcl-plan.golden b/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic.vcl-plan.golden index c6ae39b3b..28c6eee2e 100644 --- a/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic.vcl-plan.golden +++ b/vehicle/tests/golden/compile/monotonicity/Marabou.queries/monotonic.vcl-plan.golden @@ -6,261 +6,242 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "monotonic", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 1 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 1 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 1 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 1 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x2", - "userVarDimensions": [], - "unreducedUserVarName": "x2" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x1", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", - "application": 1 + "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x1", - "userVarDimensions": [], - "unreducedUserVarName": "x1" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x2", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", - "application": 0 + "application": 1 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "monotonic", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 1 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } }, { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/quantifierInIf/Marabou.err.golden b/vehicle/tests/golden/compile/quantifierInIf/Marabou.err.golden index eb37f9495..a795c7242 100644 --- a/vehicle/tests/golden/compile/quantifierInIf/Marabou.err.golden +++ b/vehicle/tests/golden/compile/quantifierInIf/Marabou.err.golden @@ -1,6 +1,5 @@  -Warning: While compiling property 'p', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints +Warning: In property 'p', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p-query1.txt.golden index e5eeadf74..96e77a763 100644 --- a/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p-query1.txt.golden +++ b/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p.vcl-plan.golden index 050d4e3c5..97733eddb 100644 --- a/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p.vcl-plan.golden +++ b/vehicle/tests/golden/compile/quantifierInIf/Marabou.queries/p.vcl-plan.golden @@ -6,147 +6,133 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "p", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 1 + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ + "tensorDims": [ 1 - ], - "constantValue": [ + ] + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/reachability/Agda.agda.golden b/vehicle/tests/golden/compile/reachability/Agda.agda.golden index 32e27a831..719bed6b2 100644 --- a/vehicle/tests/golden/compile/reachability/Agda.agda.golden +++ b/vehicle/tests/golden/compile/reachability/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/reachability/Marabou.err.golden b/vehicle/tests/golden/compile/reachability/Marabou.err.golden index 2d1e434e7..46a609b27 100644 --- a/vehicle/tests/golden/compile/reachability/Marabou.err.golden +++ b/vehicle/tests/golden/compile/reachability/Marabou.err.golden @@ -1,7 +1,6 @@  -Warning: While compiling property 'reachable', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - f₀[input]!1 - no constraints +Warning: In property 'reachable', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound + f₀[input]!1 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable-query1.txt.golden b/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable-query1.txt.golden index 0728231b2..2f45abd1b 100644 --- a/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable-query1.txt.golden +++ b/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 = 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable.vcl-plan.golden b/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable.vcl-plan.golden index e2e8e147b..f464e00d8 100644 --- a/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable.vcl-plan.golden +++ b/vehicle/tests/golden/compile/reachability/Marabou.queries/reachable.vcl-plan.golden @@ -6,65 +6,21 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "reachable", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 2 - ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ - 2 - ], - "constantValue": [ + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -74,83 +30,127 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 2 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "reachable", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-arithmetic/Agda.agda.golden b/vehicle/tests/golden/compile/simple-arithmetic/Agda.agda.golden index 81356b778..d8a42ecfb 100644 --- a/vehicle/tests/golden/compile/simple-arithmetic/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-arithmetic/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-arithmetic/Marabou.err.golden b/vehicle/tests/golden/compile/simple-arithmetic/Marabou.err.golden index 8a88df44b..d1a93fc9a 100644 --- a/vehicle/tests/golden/compile/simple-arithmetic/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-arithmetic/Marabou.err.golden @@ -1,5 +1,5 @@  -Warning: While compiling property 'property', in at least one of the generated SAT problems all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of degenerate problems. +Warning: In property 'property', in query 1 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details.  diff --git a/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property-query1.txt.golden b/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property-query1.txt.golden index 28f579ddf..0bf1d3c4e 100644 --- a/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.5 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property.vcl-plan.golden b/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property.vcl-plan.golden index bac975deb..83f262058 100644 --- a/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-arithmetic/Marabou.queries/property.vcl-plan.golden @@ -6,99 +6,71 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [], + "queryAddress": [ { "propertyName": "property", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-constantInput/Agda.agda.golden b/vehicle/tests/golden/compile/simple-constantInput/Agda.agda.golden index de8112a1b..ff788ac1a 100644 --- a/vehicle/tests/golden/compile/simple-constantInput/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-constantInput/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-constantInput/Marabou.err.golden b/vehicle/tests/golden/compile/simple-constantInput/Marabou.err.golden index 868aedd60..c889d1662 100644 --- a/vehicle/tests/golden/compile/simple-constantInput/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-constantInput/Marabou.err.golden @@ -1,13 +1,12 @@  -Warning: While compiling property 'spec', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - - -Warning: While compiling property 'spec', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'spec', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'spec', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec-query1.txt.golden b/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec-query1.txt.golden index 483fb4091..6d0eff3c8 100644 --- a/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x1 = 0.0 y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec.vcl-plan.golden b/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec.vcl-plan.golden index 47f0f6310..2ff217662 100644 --- a/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-constantInput/Marabou.queries/spec.vcl-plan.golden @@ -6,141 +6,147 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "spec", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "spec", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.err.golden b/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.err.golden index e08e6b282..e32e8df81 100644 --- a/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.err.golden @@ -1,5 +1,5 @@  -Warning: While compiling property 'p', in at least one of the generated SAT problems all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of degenerate problems. +Warning: In property 'p', in query 1 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details.  diff --git a/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p-query1.txt.golden index 6d0a927d0..9b0491809 100644 --- a/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 y0 = 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p.vcl-plan.golden index 347dc4e2f..cf337530d 100644 --- a/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-constantNetworkInput/Marabou.queries/p.vcl-plan.golden @@ -6,99 +6,71 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [], + "queryAddress": [ { "propertyName": "p", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-foreach/Marabou.err.golden b/vehicle/tests/golden/compile/simple-foreach/Marabou.err.golden index e22425944..2e32063b0 100644 --- a/vehicle/tests/golden/compile/simple-foreach/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-foreach/Marabou.err.golden @@ -1,5 +1,10 @@  -Warning: While compiling property 'index', in at least one of the generated SAT problems all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of degenerate problems. +Warning: In property 'index!0', in query 1 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. + +See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details. + + +Warning: In property 'index!1', in query 1 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details.  diff --git a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0-query1.txt.golden b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0-query1.txt.golden index 161d787c9..aa22a6c95 100644 --- a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0-query1.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 x1 = 0.0 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0.vcl-plan.golden b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0.vcl-plan.golden index daa4fcefa..8035a6dd3 100644 --- a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!0.vcl-plan.golden @@ -6,101 +6,101 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [], + "queryAddress": [ { "propertyName": "index", "propertyIndices": [ 0 - ] + ], + "propertyID": 0 }, 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1-query1.txt.golden b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1-query1.txt.golden index 95687a36b..4e4424ad2 100644 --- a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1-query1.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 x1 = 0.0 y1 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1.vcl-plan.golden b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1.vcl-plan.golden index 1b6b686a1..f1efa6a43 100644 --- a/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-foreach/Marabou.queries/index!1.vcl-plan.golden @@ -6,101 +6,101 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [], + "queryAddress": [ { "propertyName": "index", "propertyIndices": [ 1 - ] + ], + "propertyID": 0 }, 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.err.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.err.golden index 47ca5633a..aba60a3fc 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.err.golden @@ -1,36 +1,32 @@  Warning: In property 'unusedVar' the quantified variable 'y' is not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. - - -Warning: While compiling property 'unusedVar', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - - -Warning: In property 'underConstrainedVar1' the quantified variable 'y' is not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. - - -Warning: While compiling property 'underConstrainedVar1', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - f₀[input]!0 - bounded below but not above - - -Warning: In property 'underConstrainedVar2' the quantified variable 'y' is not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. - - -Warning: While compiling property 'underConstrainedVar2', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. +Warning: In property 'unusedVar', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound + + +Warning: In property 'underConstrainedVar1' the quantified variable 'x' is not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. + + +Warning: In property 'underConstrainedVar1', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no upper bound + + +Warning: In property 'underConstrainedVar2' the quantified variable 'x' is not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. + + +Warning: In property 'underConstrainedVar2', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no upper bound + + +Warning: In property 'underConstrainedVars' the quantified variables 'x!0', 'x!2', 'x!3' are not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. -In particular, the following input variables are under-specified: - f₀[input]!0 - bounded below but not above - - -Warning: In property 'underConstrainedVars' the quantified variables 'x_1', 'x_2', 'x_3' are not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. - - -Warning: While compiling property 'underConstrainedVars', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - f₀[input]!0 - bounded below but not above +Warning: In property 'underConstrainedVars', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no upper bound  diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1-query1.txt.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1-query1.txt.golden index 7c3b683ee..940499f8c 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 3.0 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1.vcl-plan.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1.vcl-plan.golden index c1982f82b..24fe93580 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar1.vcl-plan.golden @@ -6,246 +6,244 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "underConstrainedVar1", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 + "tag": "SolveRationalInequalities", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ - { - "numerator": 0, + }, + { + "upperBounds": [ + { + "strictness": "NonStrict", + "rationalIneqExpr": { + "constantValue": { + "numerator": 2, "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" - } - }, - { - "numerator": -1, - "denominator": 1 - } - ], - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 - } - ] - ] - } - } - ] - }, - { - "tag": "EliminateViaFourierMotzkin", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" - } - }, - { - "upperBounds": [ - { - "assertionRel": "LessThanOrEqualTo", - "assertionExpr": { - "dimensions": [], - "constantValue": [ + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { "numerator": 1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" - } - }, - { - "numerator": 1, - "denominator": 1 - } - ], - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": -1, - "denominator": 1 } - ] - ] - } - } - ], - "lowerBounds": [ - { - "assertionRel": "LessThanOrEqualTo", - "assertionExpr": { - "dimensions": [], - "constantValue": [ + }, { - "numerator": 2, + "numerator": -1, "denominator": 1 } - ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" + ] + ] + } + } + ], + "lowerBounds": [ + { + "strictness": "NonStrict", + "rationalIneqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - }, - { - "numerator": -1, - "denominator": 1 } - ] + }, + { + "numerator": -1, + "denominator": 1 + } ] - } + ] } + } + ] + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "y", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "y", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "underConstrainedVar1", + "propertyIndices": [], + "propertyID": 1 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2-query1.txt.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2-query1.txt.golden index 7c3b683ee..940499f8c 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 3.0 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2.vcl-plan.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2.vcl-plan.golden index 90f53ff36..9f13ea1c0 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVar2.vcl-plan.golden @@ -6,246 +6,244 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "underConstrainedVar2", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" - } - }, - { - "numerator": -1, - "denominator": 2 - } - ], - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 2 - } - ] - ] - } + "tag": "SolveRationalInequalities", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - ] - }, - { - "tag": "EliminateViaFourierMotzkin", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" - } - }, - { - "upperBounds": [ - { - "assertionRel": "LessThanOrEqualTo", - "assertionExpr": { - "dimensions": [], - "constantValue": [ + }, + { + "upperBounds": [ + { + "strictness": "NonStrict", + "rationalIneqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": 2, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": 1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" - } - }, - { - "numerator": 1, - "denominator": 1 - } - ], - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": -1, - "denominator": 1 } - ] + }, + { + "numerator": -1, + "denominator": 2 + } ] - } + ] } - ], - "lowerBounds": [ - { - "assertionRel": "LessThanOrEqualTo", - "assertionExpr": { - "dimensions": [], - "constantValue": [ + } + ], + "lowerBounds": [ + { + "strictness": "NonStrict", + "rationalIneqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 1, - "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - }, - { - "numerator": -1, - "denominator": 1 } - ] + }, + { + "numerator": -1, + "denominator": 1 + } ] - } + ] } + } + ] + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "y", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -2, + "denominator": 1 + } + ], + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "y", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "underConstrainedVar2", + "propertyIndices": [], + "propertyID": 2 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars-query1.txt.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars-query1.txt.golden index ff08f9e9a..5f4d24d44 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 2.5 y0 >= 2.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars.vcl-plan.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars.vcl-plan.golden index 0230166e6..62e312c02 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/underConstrainedVars.vcl-plan.golden @@ -6,291 +6,304 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "underConstrainedVars", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "tag": "SolveRationalInequalities", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 4 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 + ] } + }, + { + "upperBounds": [], + "lowerBounds": [] } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] } - }, - { - "numerator": -1, - "denominator": 1 } - ], - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaFourierMotzkin", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "upperBounds": [], - "lowerBounds": [ - { - "assertionRel": "LessThanOrEqualTo", - "assertionExpr": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalInequalities", + "contents": [ + { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] + } + }, + { + "upperBounds": [], + "lowerBounds": [] + } + ] + }, + { + "tag": "SolveRationalInequalities", + "contents": [ + { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] + } + }, + { + "upperBounds": [], + "lowerBounds": [ + { + "strictness": "NonStrict", + "rationalIneqExpr": { + "constantValue": { + "numerator": 1, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 2, - "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 2 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] } - }, - { - "numerator": -1, - "denominator": 1 } - ] - ] - } - } - ] - } - ] - }, - { - "tag": "EliminateViaFourierMotzkin", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "upperBounds": [], - "lowerBounds": [ - { - "assertionRel": "LessThanOrEqualTo", - "assertionExpr": { - "dimensions": [], - "constantValue": [ + }, { - "numerator": 1, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_2", - "userVarDimensions": [], - "unreducedUserVarName": "x" + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] } - }, - { - "numerator": -1, - "denominator": 1 } - ], - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_3", - "userVarDimensions": [], - "unreducedUserVarName": "x" + }, + { + "numerator": -1, + "denominator": 1 + } + ] + ] + } + }, + { + "strictness": "NonStrict", + "rationalIneqExpr": { + "constantValue": { + "numerator": 2, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 3 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 4 + ] } - }, - { - "numerator": -1, - "denominator": 1 } - ] + }, + { + "numerator": -1, + "denominator": 1 + } ] - } + ] } - ] - } - ] + } + ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "underConstrainedVars", + "propertyIndices": [], + "propertyID": 3 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "EliminateViaFourierMotzkin", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "upperBounds": [], - "lowerBounds": [] - } - ] + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar-query1.txt.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar-query1.txt.golden index 3fb839e8f..e7a83fb93 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar.vcl-plan.golden b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar.vcl-plan.golden index 0ef144ece..0424d6742 100644 --- a/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-fourierMotzkin/Marabou.queries/unusedVar.vcl-plan.golden @@ -6,158 +6,149 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "unusedVar", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + }, + { + "tag": "SolveRationalInequalities", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "y", + "userTensorVarDimensions": [] + } + }, + { + "upperBounds": [], + "lowerBounds": [] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "unusedVar", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "EliminateViaFourierMotzkin", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [], - "unreducedUserVarName": "y" - } - }, - { - "upperBounds": [], - "lowerBounds": [] - } - ] + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.err.golden b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.err.golden index e95b8fcf3..3967b1c04 100644 --- a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.err.golden @@ -1,13 +1,11 @@  -Warning: While compiling property 'test1', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. +Warning: In property 'test1', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no upper bound -In particular, the following input variables are under-specified: - f₀[input]!0 - bounded below but not above - - -Warning: While compiling property 'test2', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - g₀[input]!0 - no constraints - g₀[input]!1 - no constraints +Warning: In property 'test2', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + g₀[input]!0 - no lower or upper bound + g₀[input]!1 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1-query1.txt.golden b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1-query1.txt.golden index a3bb36d5b..c7d6293ac 100644 --- a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 2.0 y0 = 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1.vcl-plan.golden b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1.vcl-plan.golden index a30f2ec8a..33eebed46 100644 --- a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test1.vcl-plan.golden @@ -6,141 +6,133 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "test1", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "a", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "a", - "userVarDimensions": [], - "unreducedUserVarName": "a" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": -2, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "a", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": -2, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "test1", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2-query1.txt.golden b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2-query1.txt.golden index 15063cb3a..1d71bb3ac 100644 --- a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2-query1.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev -2.0x0 +x1 <= -1.0 3.0x0 -2.0x1 <= 0.0 y0 = 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2.vcl-plan.golden b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2.vcl-plan.golden index ab82229ee..42b6d6006 100644 --- a/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-gaussianElim/Marabou.queries/test2.vcl-plan.golden @@ -6,213 +6,247 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "test2", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "g", - "inputOrOutput": "Output", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "a", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "g", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "g", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "g", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "b", - "userVarDimensions": [], - "unreducedUserVarName": "b" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "a", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": 1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "g", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": -1, - "denominator": 1 } - ], - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + }, + { + "numerator": -2, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "g", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "a", - "userVarDimensions": [], - "unreducedUserVarName": "a" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "b", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "a", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "b", - "userVarDimensions": [], - "unreducedUserVarName": "b" + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "b", + "userTensorVarDimensions": [] } - }, - { - "numerator": -1, - "denominator": 1 } - ], - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "g", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "test2", + "propertyIndices": [], + "propertyID": 1 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "g", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "g", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "g", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "g", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-generalisedVariables/Agda.agda.golden b/vehicle/tests/golden/compile/simple-generalisedVariables/Agda.agda.golden index 9a95078c3..500a978f9 100644 --- a/vehicle/tests/golden/compile/simple-generalisedVariables/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-generalisedVariables/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-if/Agda.agda.golden b/vehicle/tests/golden/compile/simple-if/Agda.agda.golden index a023eedf3..113fc05e5 100644 --- a/vehicle/tests/golden/compile/simple-if/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-if/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.err.golden b/vehicle/tests/golden/compile/simple-if/Marabou.err.golden index 6103b6276..6299f8bbe 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.err.golden @@ -1,47 +1,42 @@  -Warning: While compiling property 'prop1', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - bounded below but not above - - -Warning: While compiling property 'prop1', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'prop1', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: While compiling property 'prop2', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - f₀[input]!0 - bounded below but not above - - -Warning: While compiling property 'prop2', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + +Warning: In property 'prop1', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no upper bound + In query 2: + f₀[input]!0 - no lower bound + + +Warning: In property 'prop2', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: In property 'prop2' the quantified variable 'x' is not always directly related to the input or output of a network. This is frequently indicative of a bug in the specification. - - -Warning: While compiling property 'prop2', in at least one of the generated SAT problems all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of degenerate problems. -See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details. - - -Warning: While compiling property 'prop3', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - f₀[input]!0 - bounded below but not above - - -Warning: While compiling property 'prop3', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'prop2', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no upper bound + In query 2: + f₀[input]!0 - no lower bound + + +Warning: In property 'prop3', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'prop3', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no upper bound + In query 2: + f₀[input]!0 - no lower bound  diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query1.txt.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query1.txt.golden index 04adf253e..1593b4c99 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query2.txt.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query2.txt.golden index 2b3863909..a34dde40a 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query2.txt.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1-query2.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 <= 0.0 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1.vcl-plan.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1.vcl-plan.golden index bc0a0327e..e74fae68e 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop1.vcl-plan.golden @@ -6,276 +6,260 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "prop1", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "prop1", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, + "metaNetwork": { + "variables": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "prop1", + "propertyIndices": [], + "propertyID": 0 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query1.txt.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query1.txt.golden index 3b5d65499..b4825d704 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query1.txt.golden @@ -2,6 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 +x1 = 0.2 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query2.txt.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query2.txt.golden index 1b82759ca..409cefb64 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query2.txt.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2-query2.txt.golden @@ -2,6 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev -x0 = 0.2 -y0 >= 0.0 \ No newline at end of file +// - Vehicle version: 0.11.1+dev +x0 <= 0.0 +x1 = 0.2 +y1 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2.vcl-plan.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2.vcl-plan.golden index 1f5de7fce..4cc30fe9a 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop2.vcl-plan.golden @@ -6,280 +6,356 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ { "propertyName": "prop2", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 1 }, 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 1 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" } }, { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "prop2", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 1 }, 2 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 1 } - }, - { - "tag": "EliminateViaFourierMotzkin", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "upperBounds": [ - { - "assertionRel": "LessThanOrEqualTo", - "assertionExpr": { - "dimensions": [], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "numerator": 1, - "denominator": 1 - } - ] - ] - } - } - ], - "lowerBounds": [] - } - ] } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, + "networkFilepath": "fake.onnx" + } + }, + { "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query1.txt.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query1.txt.golden index 3b5d65499..68b18a2ac 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 >= 0.0 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query2.txt.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query2.txt.golden index 6beb5953f..876ebae39 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query2.txt.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3-query2.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 <= 0.0 y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3.vcl-plan.golden b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3.vcl-plan.golden index 6205d1ede..41aefb2fb 100644 --- a/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-if/Marabou.queries/prop3.vcl-plan.golden @@ -6,276 +6,260 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "prop3", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } - } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] + ] } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "prop3", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 2 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, + "metaNetwork": { + "variables": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "fake.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": 0, + "denominator": 1 + }, + "coefficients": [ + [ + { + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [] + } + } + }, { - "numerator": 0, + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 1, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "prop3", + "propertyIndices": [], + "propertyID": 2 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/simple-if/spec.vcl b/vehicle/tests/golden/compile/simple-if/spec.vcl index 2fad48034..e91af5ea8 100644 --- a/vehicle/tests/golden/compile/simple-if/spec.vcl +++ b/vehicle/tests/golden/compile/simple-if/spec.vcl @@ -19,3 +19,6 @@ prop3 = exists x . if f [x] ! 0 > 0 then x >= 0 else x < 0 -- @property -- prop4 : Bool -- prop4 = exists x . (map (\v -> if v > 0 then 1 else 2) (g x)) ! 0 > 0 + + +-- exists a . (x2 == 0.2 and x1 > 0 and y1 >= 0) or (x2 == 0.2 and x1 <= 0 and y2 >= 0) diff --git a/vehicle/tests/golden/compile/simple-index/Agda.agda.golden b/vehicle/tests/golden/compile/simple-index/Agda.agda.golden index 9a95078c3..500a978f9 100644 --- a/vehicle/tests/golden/compile/simple-index/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-index/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query1.txt.golden b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query1.txt.golden index e6e6c96b5..e0d92a5f5 100644 --- a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.10000000149011612 y0 <= 0.0 diff --git a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query2.txt.golden b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query2.txt.golden index 250d07df3..0499a1cf3 100644 --- a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query2.txt.golden +++ b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query2.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 3.0 y0 <= 0.0 diff --git a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query3.txt.golden b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query3.txt.golden index 0a507d109..ca0572c7c 100644 --- a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query3.txt.golden +++ b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query3.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = -2.0 y0 <= 0.0 diff --git a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query4.txt.golden b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query4.txt.golden index 5b11a1f82..8c6621767 100644 --- a/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query4.txt.golden +++ b/vehicle/tests/golden/compile/simple-inferableParam/Marabou.queries/positive-query4.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = -3.200000047683716 y0 <= 0.0 diff --git a/vehicle/tests/golden/compile/simple-let/Agda.agda.golden b/vehicle/tests/golden/compile/simple-let/Agda.agda.golden index 434e9c2e0..a8a802af9 100644 --- a/vehicle/tests/golden/compile/simple-let/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-let/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-pruneDecls/Agda.agda.golden b/vehicle/tests/golden/compile/simple-pruneDecls/Agda.agda.golden index c93dd2c04..513597ddc 100644 --- a/vehicle/tests/golden/compile/simple-pruneDecls/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-pruneDecls/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.err.golden b/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.err.golden index 52a93de0c..57e655d72 100644 --- a/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.err.golden @@ -1,14 +1,13 @@  -Warning: While compiling property 'p2', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - g₀[input]!0 - no constraints - g₀[input]!1 - no constraints - - -Warning: While compiling property 'p2', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'p2', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'p2', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + g₀[input]!0 - no lower or upper bound + g₀[input]!1 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2-query1.txt.golden b/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2-query1.txt.golden index e5eeadf74..96e77a763 100644 --- a/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2.vcl-plan.golden b/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2.vcl-plan.golden index 34ad2e69d..b7e2d257c 100644 --- a/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-pruneDecls/Marabou.queries/p2.vcl-plan.golden @@ -6,65 +6,21 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "p2", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "g", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "g", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 2 - ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ - 2 - ], - "constantValue": [ + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ { "numerator": 0, "denominator": 1 @@ -74,83 +30,127 @@ "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "g", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + "tensorDims": [ + 2 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "g", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "p2", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "g", + "inputOrOutput": "Input", + "application": 0 + } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "g", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "g", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "g", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "g", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "g", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/simple-quantifier/Agda.agda.golden b/vehicle/tests/golden/compile/simple-quantifier/Agda.agda.golden index 6e953397f..5610110f5 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.err.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.err.golden index e0e637880..1bd39ba1c 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.err.golden @@ -1,40 +1,37 @@  -Warning: While compiling property 'expandedExpr', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. - -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - - -Warning: While compiling property 'expandedExpr', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). +Warning: In property 'expandedExpr', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: While compiling property 'sequential', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - f₁[input]!0 - no constraints - - -Warning: While compiling property 'sequential', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + +Warning: In property 'expandedExpr', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound + + +Warning: In property 'sequential', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. - - -Warning: While compiling property 'parallel', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - - -Warning: While compiling property 'parallel', at least one of the generated SAT problems was found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). + +Warning: In property 'sequential', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound + f₁[input]!0 - no lower or upper bound + + +Warning: In property 'parallel', at least one of the generated queries were found to contain a strict inequality (i.e. constraints of the form 'x < y'). Unfortunately the Marabou query format only supports non-strict inequalities (i.e. constraints of the form 'x <= y'). In order to provide support, Vehicle has automatically converted the strict inequalities to non-strict inequalites. This is not sound, but errors will be at most the floating point epsilon used by the verifier, which is usually very small (e.g. 1e-9). However, this may lead to unexpected behaviour (e.g. loss of the law of excluded middle). See https://github.com/vehicle-lang/vehicle/issues/74 for further details. + + +Warning: In property 'parallel', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In queries 1 and 2: + f₀[input]!0 - no lower or upper bound  diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr-query1.txt.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr-query1.txt.golden index ee8e61dea..822eb0eed 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +x0 -y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr.vcl-plan.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr.vcl-plan.golden index 2a6a88566..1a9c4e196 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/expandedExpr.vcl-plan.golden @@ -6,147 +6,133 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "expandedExpr", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 1 + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ + "tensorDims": [ 1 - ], - "constantValue": [ + ] + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "expandedExpr", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query1.txt.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query1.txt.golden index e5eeadf74..96e77a763 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query2.txt.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query2.txt.golden index db8756075..9bc9d7ead 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query2.txt.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel-query2.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 >= 5.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel.vcl-plan.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel.vcl-plan.golden index 31c4e7364..169afc0ba 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/parallel.vcl-plan.golden @@ -3,83 +3,59 @@ "tag": "NonTrivial", "contents": { "tag": "Conjunct", - "contents": [ - { - "tag": "Query", - "contents": { - "queries": { - "unDisjunctAll": [ - [ - [ - { - "propertyName": "parallel", - "propertyIndices": [] - }, - 1 - ], + "contents": { + "unConjunctAll": [ + { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ { "variableReconstruction": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", + "tag": "SolveTensorEquality", "contents": [ { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 1 - ], - "unreducedUserVarName": "x" - } + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] }, { - "solutionEquality": { - "dimensions": [ - 1 - ], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - } - ], + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } + ], + "tensorDims": [ + 1 + ] + }, "coefficients": [ [ { - "tag": "NetworkVar", + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "startingIndex": 0, + "networkTensorVarDimensions": [ 1 ], "networkName": "f", @@ -96,29 +72,39 @@ } } ] - }, + } + ], + "queryAddress": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "propertyName": "parallel", + "propertyIndices": [], + "propertyID": 2 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ 1 ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ 1 ], "networkName": "f", @@ -126,111 +112,87 @@ "application": 0 } } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] + } + ] + } } ] - ] - }, - "negated": true - } - }, - { - "tag": "Query", - "contents": { - "queries": { - "unDisjunctAll": [ - [ - [ - { - "propertyName": "parallel", - "propertyIndices": [] - }, - 2 - ], + }, + "negated": true + } + }, + { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ { "variableReconstruction": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", + "tag": "SolveTensorEquality", "contents": [ { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 1 - ], - "unreducedUserVarName": "x" - } + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] }, { - "solutionEquality": { - "dimensions": [ - 1 - ], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - } - ], + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } + ], + "tensorDims": [ + 1 + ] + }, "coefficients": [ [ { - "tag": "NetworkVar", + "tag": "UserTensorVar", "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ 1 ], "networkName": "f", @@ -247,29 +209,39 @@ } } ] - }, + } + ], + "queryAddress": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "propertyName": "parallel", + "propertyIndices": [], + "propertyID": 2 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ 1 ], "networkName": "f", "inputOrOutput": "Input", "application": 0 } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ 1 ], "networkName": "f", @@ -277,36 +249,38 @@ "application": 0 } } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] + } + ] + } } ] - ] - }, - "negated": false + }, + "negated": false + } } - } - ] + ] + } } } } \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential-query1.txt.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential-query1.txt.golden index 663ad9bcc..6722508e0 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev +y0 -y1 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential.vcl-plan.golden b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential.vcl-plan.golden index 6ab110531..3cbcce563 100644 --- a/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-quantifier/Marabou.queries/sequential.vcl-plan.golden @@ -6,273 +6,242 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "sequential", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 1 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 1 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "y", - "userVarDimensions": [ - 1 + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } ], - "unreducedUserVarName": "y" - } - }, - { - "solutionEquality": { - "dimensions": [ + "tensorDims": [ 1 - ], - "constantValue": [ + ] + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 1 - } - }, - { - "numerator": 1, - "denominator": 1 + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 1 + } + ] + }, + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "y", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [ + "tensorDims": [ 1 - ], - "constantValue": [ + ] + }, + "coefficients": [ + [ { - "numerator": 0, + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "y", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, "denominator": 1 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "sequential", + "propertyIndices": [], + "propertyID": 1 + }, + 1 + ], + "metaNetwork": { + "variables": [ { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 1 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 1 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 1 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 1, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 1 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } }, { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/compile/simple-quantifierIn/Agda.agda.golden b/vehicle/tests/golden/compile/simple-quantifierIn/Agda.agda.golden index ba1279814..9499d47be 100644 --- a/vehicle/tests/golden/compile/simple-quantifierIn/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-quantifierIn/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-quantifierIn/Marabou.queries/forallInForall-query1.txt.golden b/vehicle/tests/golden/compile/simple-quantifierIn/Marabou.queries/forallInForall-query1.txt.golden index e5655cbc9..f922b347c 100644 --- a/vehicle/tests/golden/compile/simple-quantifierIn/Marabou.queries/forallInForall-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-quantifierIn/Marabou.queries/forallInForall-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.5 x1 = 1.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-tensor/Agda.agda.golden b/vehicle/tests/golden/compile/simple-tensor/Agda.agda.golden index 0cfb7adcf..47db7d4be 100644 --- a/vehicle/tests/golden/compile/simple-tensor/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-tensor/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-tensor/Marabou.err.golden b/vehicle/tests/golden/compile/simple-tensor/Marabou.err.golden index e08e6b282..0c5f72b58 100644 --- a/vehicle/tests/golden/compile/simple-tensor/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-tensor/Marabou.err.golden @@ -1,5 +1,5 @@  -Warning: While compiling property 'p', in at least one of the generated SAT problems all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of degenerate problems. +Warning: In property 'p', in queries 1, 2, 3 and 4 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details.  diff --git a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query1.txt.golden index 0cbfd20ff..bc91f8780 100644 --- a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query1.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 x1 = 0.0 x2 = 0.0 diff --git a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query2.txt.golden b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query2.txt.golden index 17557cfe2..65c29b239 100644 --- a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query2.txt.golden +++ b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query2.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 x1 = 0.0 x2 = 0.0 diff --git a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query3.txt.golden b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query3.txt.golden index 90132aa57..b40f604de 100644 --- a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query3.txt.golden +++ b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query3.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 x1 = 0.0 x2 = 0.0 diff --git a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query4.txt.golden b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query4.txt.golden index 905f3a153..b2adbf92c 100644 --- a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query4.txt.golden +++ b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p-query4.txt.golden @@ -2,7 +2,7 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 x1 = 0.0 x2 = 0.0 diff --git a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p.vcl-plan.golden index f26aefcf8..c6eea04fe 100644 --- a/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-tensor/Marabou.queries/p.vcl-plan.golden @@ -3,93 +3,159 @@ "tag": "NonTrivial", "contents": { "tag": "Conjunct", - "contents": [ - { - "tag": "Conjunct", - "contents": [ - { - "tag": "Query", - "contents": { - "queries": { - "unDisjunctAll": [ - [ - [ - { - "propertyName": "p", - "propertyIndices": [] - }, - 1 - ], + "contents": { + "unConjunctAll": [ + { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [], + "queryAddress": [ { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 1 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { "outputTensor": { "dimensions": [ 2, @@ -105,100 +171,168 @@ "baseType": [] } }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ] - ] - }, - "negated": false - } - }, - { - "tag": "Query", - "contents": { - "queries": { - "unDisjunctAll": [ - [ - [ - { - "propertyName": "p", - "propertyIndices": [] - }, - 2 - ], + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": false + } + }, + { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [], + "queryAddress": [ { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { "outputTensor": { "dimensions": [ 2, @@ -214,105 +348,168 @@ "baseType": [] } }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ] - ] - }, - "negated": false - } + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": false } - ] - }, - { - "tag": "Conjunct", - "contents": [ - { - "tag": "Query", - "contents": { - "queries": { - "unDisjunctAll": [ - [ - [ - { - "propertyName": "p", - "propertyIndices": [] - }, - 3 - ], + }, + { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [], + "queryAddress": [ { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 3 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { "outputTensor": { "dimensions": [ 2, @@ -328,100 +525,168 @@ "baseType": [] } }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ] - ] - }, - "negated": false - } - }, - { - "tag": "Query", - "contents": { - "queries": { - "unDisjunctAll": [ - [ - [ - { - "propertyName": "p", - "propertyIndices": [] - }, - 4 - ], + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": false + } + }, + { + "tag": "Query", + "contents": { + "queries": { + "unDisjunctAll": [ + { + "variableReconstruction": [], + "queryAddress": [ { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2, - 2 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } + "propertyName": "p", + "propertyIndices": [], + "propertyID": 0 + }, + 4 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 1, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + }, + { + "tensorIndices": [ + 0, + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2, + 2 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 + } + } + ], + "networkEntries": [ + { + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { "outputTensor": { "dimensions": [ 2, @@ -437,20 +702,19 @@ "baseType": [] } }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" - } - ] - } - ] - ] - }, - "negated": false - } + "networkFilepath": "fake.onnx" + } + } + ] + } + } + ] + }, + "negated": false } - ] - } - ] + } + ] + } } } } \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-untypedDecls/Agda.agda.golden b/vehicle/tests/golden/compile/simple-untypedDecls/Agda.agda.golden index 9a95078c3..500a978f9 100644 --- a/vehicle/tests/golden/compile/simple-untypedDecls/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-untypedDecls/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-vector/Agda.agda.golden b/vehicle/tests/golden/compile/simple-vector/Agda.agda.golden index 312fa9e06..1bc62847b 100644 --- a/vehicle/tests/golden/compile/simple-vector/Agda.agda.golden +++ b/vehicle/tests/golden/compile/simple-vector/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/simple-vector/Marabou.err.golden b/vehicle/tests/golden/compile/simple-vector/Marabou.err.golden index e08e6b282..e32e8df81 100644 --- a/vehicle/tests/golden/compile/simple-vector/Marabou.err.golden +++ b/vehicle/tests/golden/compile/simple-vector/Marabou.err.golden @@ -1,5 +1,5 @@  -Warning: While compiling property 'p', in at least one of the generated SAT problems all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of degenerate problems. +Warning: In property 'p', in query 1 all network inputs were fixed to be constants. Unfortunately there is a known bug in Marabou that it sometimes erroneously returns 'unsat' for these type of queries. See https://github.com/NeuralNetworkVerification/Marabou/issues/670 for details.  diff --git a/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p-query1.txt.golden b/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p-query1.txt.golden index 5b925b9bf..2a169716d 100644 --- a/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p-query1.txt.golden +++ b/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p-query1.txt.golden @@ -2,6 +2,6 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev x0 = 0.0 y0 >= 0.0 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p.vcl-plan.golden b/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p.vcl-plan.golden index 347dc4e2f..cf337530d 100644 --- a/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p.vcl-plan.golden +++ b/vehicle/tests/golden/compile/simple-vector/Marabou.queries/p.vcl-plan.golden @@ -6,99 +6,71 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [], + "queryAddress": [ { "propertyName": "p", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + } + }, + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": false diff --git a/vehicle/tests/golden/compile/windController/Agda.agda.golden b/vehicle/tests/golden/compile/windController/Agda.agda.golden index c391a50f4..cbc196992 100644 --- a/vehicle/tests/golden/compile/windController/Agda.agda.golden +++ b/vehicle/tests/golden/compile/windController/Agda.agda.golden @@ -2,7 +2,7 @@ -- and should not be modified manually! -- Metadata: -- - Agda version: 2.6.2 --- - Vehicle version: 0.11.0+dev +-- - Vehicle version: 0.11.1+dev {-# OPTIONS --allow-exec #-} diff --git a/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query1.txt.golden b/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query1.txt.golden index 35836e22f..8f4c6adcc 100644 --- a/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query1.txt.golden +++ b/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query1.txt.golden @@ -2,9 +2,9 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev -x0 >= 0.09375 -x0 <= 0.90625 +// - Vehicle version: 0.11.1+dev 16.0x0 -8.0x1 +y0 <= 2.75 -x1 >= 0.09375 -x1 <= 0.90625 \ No newline at end of file +x0 <= 0.90625 +x0 >= 0.09375 +x1 <= 0.90625 +x1 >= 0.09375 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query2.txt.golden b/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query2.txt.golden index a67b75f8b..d28693124 100644 --- a/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query2.txt.golden +++ b/vehicle/tests/golden/compile/windController/Marabou.queries/safe-query2.txt.golden @@ -2,9 +2,9 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev -16.0x0 8.0x1 -y0 <= -5.25 -x0 >= 0.09375 x0 <= 0.90625 -x1 >= 0.09375 -x1 <= 0.90625 \ No newline at end of file +x0 >= 0.09375 +x1 <= 0.90625 +x1 >= 0.09375 \ No newline at end of file diff --git a/vehicle/tests/golden/compile/windController/Marabou.queries/safe.vcl-plan.golden b/vehicle/tests/golden/compile/windController/Marabou.queries/safe.vcl-plan.golden index 6428d6faa..f12e88fb7 100644 --- a/vehicle/tests/golden/compile/windController/Marabou.queries/safe.vcl-plan.golden +++ b/vehicle/tests/golden/compile/windController/Marabou.queries/safe.vcl-plan.golden @@ -6,386 +6,442 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ { - "propertyName": "safe", - "propertyIndices": [] - }, - 1 - ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "controller", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "controller", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 2 - ], - "unreducedUserVarName": "x" - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ 2 - ], - "networkName": "controller", - "inputOrOutput": "Input", - "application": 0 + ] } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "controller", - "inputOrOutput": "Output", - "application": 0 - } - } - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": -1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": -4, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + } + }, + { + "numerator": -1, + "denominator": 8 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "controller", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 8, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": -1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": -4, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + } + }, + { + "numerator": -1, + "denominator": 8 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "controller", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 8, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "controller", - "metaNetworkEntryFilePath": "controller.onnx" - } - ] - } - ], - [ - [ + } + ] + } + ], + "queryAddress": [ { "propertyName": "safe", - "propertyIndices": [] + "propertyIndices": [], + "propertyID": 0 }, - 2 + 1 ], - { - "variableReconstruction": [ - { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "controller", - "inputOrOutput": "Output", - "application": 0 - } - } - }, + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "controller", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ - 2 - ], - "unreducedUserVarName": "x" - } + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "controller", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 2 - ], - "networkName": "controller", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "controller", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "controller", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "controller", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_1", - "userVarDimensions": [], - "unreducedUserVarName": "x" + "metaNetworkEntryName": "controller", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] } }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + "networkFilepath": "controller.onnx" + } + } + ] + } + }, + { + "variableReconstruction": [ + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": -1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": -4, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + } + }, + { + "numerator": -1, + "denominator": 8 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 1, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "controller", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 8, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] - }, - { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x_0", - "userVarDimensions": [], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { - "dimensions": [], - "constantValue": [ + } + ] + }, + { + "tag": "SolveRationalEquality", + "contents": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + }, + { + "rationalEqExpr": { + "constantValue": { + "numerator": -1, + "denominator": 2 + }, + "coefficients": [ + [ { - "numerator": -4, - "denominator": 1 + "tag": "UserRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 2 + ] + } + } + }, + { + "numerator": -1, + "denominator": 8 } ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": 0, - "networkVarDimensions": [], + [ + { + "tag": "NetworkRationalVar", + "contents": { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], "networkName": "controller", "inputOrOutput": "Input", "application": 0 } - }, - { - "numerator": 8, - "denominator": 1 } - ] + }, + { + "numerator": 1, + "denominator": 1 + } ] - } + ] } - ] + } + ] + } + ], + "queryAddress": [ + { + "propertyName": "safe", + "propertyIndices": [], + "propertyID": 0 + }, + 2 + ], + "metaNetwork": { + "variables": [ + { + "tensorIndices": [ + 1 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "controller", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 2 + ], + "networkName": "controller", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "controller", + "inputOrOutput": "Output", + "application": 0 + } } ], - "metaNetwork": [ + "networkEntries": [ { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - }, - "inputTensor": { - "dimensions": [ - 2 - ], - "baseType": [] - } - }, "metaNetworkEntryName": "controller", - "metaNetworkEntryFilePath": "controller.onnx" + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ + 1 + ], + "baseType": [] + }, + "inputTensor": { + "dimensions": [ + 2 + ], + "baseType": [] + } + }, + "networkFilepath": "controller.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/warning/trivial/Marabou.err.golden b/vehicle/tests/golden/warning/trivial/Marabou.err.golden index 41b704871..4b1c4c93d 100644 --- a/vehicle/tests/golden/warning/trivial/Marabou.err.golden +++ b/vehicle/tests/golden/warning/trivial/Marabou.err.golden @@ -1,15 +1,14 @@  -Warning: The property 'p' was found to evalute to 'True' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used. - - -Warning: The property 'multiProperty!0!0' was found to evalute to 'True' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used. - - -Warning: While compiling property 'multiProperty', in at least one of the generated SAT problems not all network input variables have both a lower and a upper bound. Such queries are not currently supported by the Marabou query format. +Warning: The property 'p' was found to evaluate to 'True' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used. -In particular, the following input variables are under-specified: - f₀[input]!0 - no constraints - - -Warning: The property 'multiProperty!0!2' was found to evalute to 'False' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used. + +Warning: The property 'multiProperty!0!2' was found to evaluate to 'False' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used. + + +Warning: The property 'multiProperty!0!0' was found to evaluate to 'True' without needing to call the verifier. This usually indicates a fault with either the specification or any external datasets used. + + +Warning: In property 'multiProperty!0!1', the following network input variables do not always have both a lower and a upper bound. This is not currently supported by the Marabou query format. + In query 1: + f₀[input]!0 - no lower or upper bound  diff --git a/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!0!1.vcl-plan.golden b/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!0!1.vcl-plan.golden index f576a6523..c7cd21346 100644 --- a/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!0!1.vcl-plan.golden +++ b/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!0!1.vcl-plan.golden @@ -6,150 +6,136 @@ "contents": { "queries": { "unDisjunctAll": [ - [ - [ + { + "variableReconstruction": [ + { + "tag": "SolveTensorEquality", + "contents": [ + { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + }, + { + "tensorEqExpr": { + "constantValue": { + "tensorValues": [ + { + "numerator": 0, + "denominator": 1 + } + ], + "tensorDims": [ + 1 + ] + }, + "coefficients": [ + [ + { + "tag": "UserTensorVar", + "contents": { + "userTensorVarName": "x", + "userTensorVarDimensions": [ + 1 + ] + } + }, + { + "numerator": -1, + "denominator": 1 + } + ], + [ + { + "tag": "NetworkTensorVar", + "contents": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 + } + }, + { + "numerator": 1, + "denominator": 1 + } + ] + ] + } + } + ] + } + ], + "queryAddress": [ { "propertyName": "multiProperty", "propertyIndices": [ 0, 1 - ] + ], + "propertyID": 1 }, 1 ], - { - "variableReconstruction": [ + "metaNetwork": { + "variables": [ { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Input", + "application": 0 } }, { - "tag": "Introduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } + "tensorIndices": [ + 0 + ], + "originalVar": { + "startingIndex": 0, + "networkTensorVarDimensions": [ + 1 + ], + "networkName": "f", + "inputOrOutput": "Output", + "application": 0 } - }, + } + ], + "networkEntries": [ { - "tag": "EliminateViaGaussian", - "contents": [ - { - "tag": "UserVar", - "contents": { - "userVarName": "x", - "userVarDimensions": [ + "metaNetworkEntryName": "f", + "metaNetworkEntryInfo": { + "networkType": { + "outputTensor": { + "dimensions": [ 1 ], - "unreducedUserVarName": "x" - } - }, - { - "solutionEquality": { + "baseType": [] + }, + "inputTensor": { "dimensions": [ 1 ], - "constantValue": [ - { - "numerator": 0, - "denominator": 1 - } - ], - "coefficients": [ - [ - { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - }, - { - "numerator": 1, - "denominator": 1 - } - ] - ] + "baseType": [] } - } - ] - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Input", - "application": 0 - } - } - }, - { - "tag": "Reduce", - "contents": { - "tag": "NetworkVar", - "contents": { - "networkVarIndices": null, - "networkVarDimensions": [ - 1 - ], - "networkName": "f", - "inputOrOutput": "Output", - "application": 0 - } - } - } - ], - "metaNetwork": [ - { - "metaNetworkEntryType": { - "outputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] }, - "inputTensor": { - "dimensions": [ - 1 - ], - "baseType": [] - } - }, - "metaNetworkEntryName": "f", - "metaNetworkEntryFilePath": "fake.onnx" + "networkFilepath": "fake.onnx" + } } ] } - ] + } ] }, "negated": true diff --git a/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!1!0-query1.txt.golden b/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!1!0-query1.txt.golden index e5eeadf74..96e77a763 100644 --- a/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!1!0-query1.txt.golden +++ b/vehicle/tests/golden/warning/trivial/Marabou.queries/multiProperty!1!0-query1.txt.golden @@ -2,5 +2,5 @@ // and should not be modified manually! // Metadata: // - Marabou query format version: unknown -// - Vehicle version: 0.11.0+dev +// - Vehicle version: 0.11.1+dev y0 <= 0.0 \ No newline at end of file diff --git a/vehicle/tests/unit/Vehicle/Test/Unit/Common.hs b/vehicle/tests/unit/Vehicle/Test/Unit/Common.hs index 1de8603c4..72cfab229 100644 --- a/vehicle/tests/unit/Vehicle/Test/Unit/Common.hs +++ b/vehicle/tests/unit/Vehicle/Test/Unit/Common.hs @@ -49,8 +49,11 @@ unitTestCase testName errorOrAssertionWithLogs = traceLogs :: LoggingLevel -> ExceptT CompileError (DelayedLoggerT IO) Assertion -> Assertion traceLogs logLevel e = do let e' = logCompileError e - (v, logs) <- runDelayedLoggerT logLevel e' - let result = if null logs then v else trace (showMessages logs) v + (v, logs, warnings) <- runDelayedLoggerT logLevel e' + let result = + if null logs && null warnings + then v + else trace (show logs <> showCompileWarnings warnings) v case result of Left x -> developerError $ pretty $ details x Right y -> y diff --git a/vehicle/tests/unit/Vehicle/Test/Unit/Compile/DeBruijn.hs b/vehicle/tests/unit/Vehicle/Test/Unit/Compile/DeBruijn.hs index 3a6268d5a..bd9ff81be 100644 --- a/vehicle/tests/unit/Vehicle/Test/Unit/Compile/DeBruijn.hs +++ b/vehicle/tests/unit/Vehicle/Test/Unit/Compile/DeBruijn.hs @@ -4,7 +4,7 @@ import Test.Tasty (TestTree, testGroup) import Test.Tasty.HUnit (assertBool) import Vehicle.Compile.Prelude import Vehicle.Compile.Print (prettyVerbose) -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Data.DeBruijn (liftDBIndices, substDBInto) import Vehicle.Syntax.Builtin import Vehicle.Test.Unit.Common (unitTestCase) diff --git a/vehicle/tests/unit/Vehicle/Test/Unit/Compile/Normalisation.hs b/vehicle/tests/unit/Vehicle/Test/Unit/Compile/Normalisation.hs index c3020b330..435da5785 100644 --- a/vehicle/tests/unit/Vehicle/Test/Unit/Compile/Normalisation.hs +++ b/vehicle/tests/unit/Vehicle/Test/Unit/Compile/Normalisation.hs @@ -12,7 +12,7 @@ import Vehicle.Compile.Normalise.Quote (Quote (..)) import Vehicle.Compile.Prelude import Vehicle.Compile.Print (prettyVerbose) import Vehicle.Compile.Type.Subsystem.Standard -import Vehicle.Data.BuiltinInterface +import Vehicle.Data.BuiltinInterface.Expr import Vehicle.Data.NormalisedExpr import Vehicle.Test.Unit.Common (unitTestCase) @@ -93,5 +93,5 @@ p = mempty binding :: Type Ix Builtin -> Binder Ix Builtin binding = Binder p (BinderDisplayForm (OnlyName "x") False) Explicit Relevant -mkNoOpEnv :: Lv -> WHNFEnv builtin +mkNoOpEnv :: Lv -> WHNFBoundEnv builtin mkNoOpEnv boundCtxSize = [mkDefaultEnvEntry "_" Bound | _ <- [0 .. boundCtxSize - 1]] diff --git a/vehicle/vehicle.cabal b/vehicle/vehicle.cabal index 8dd877edb..851c26f69 100644 --- a/vehicle/vehicle.cabal +++ b/vehicle/vehicle.cabal @@ -1,6 +1,6 @@ cabal-version: 3.4 name: vehicle -version: 0.11.0 +version: 0.11.1 description: Please see the README on GitHub at @@ -120,15 +120,6 @@ library Vehicle.Backend.LossFunction Vehicle.Backend.Prelude Vehicle.Backend.Queries.Error - Vehicle.Backend.Queries.FourierMotzkinElimination - Vehicle.Backend.Queries.GaussianElimination - Vehicle.Backend.Queries.IfElimination - Vehicle.Backend.Queries.LinearExpr - Vehicle.Backend.Queries.NetworkElimination - Vehicle.Backend.Queries.QuerySetStructure - Vehicle.Backend.Queries.UserVariableElimination - Vehicle.Backend.Queries.Variable - Vehicle.Backend.Queries.VariableReconstruction Vehicle.Backend.Tensors.Clean Vehicle.CommandLine Vehicle.Compile @@ -155,10 +146,13 @@ library Vehicle.Compile.Type.Subsystem.Standard Vehicle.Data.BooleanExpr Vehicle.Data.BuiltinInterface - Vehicle.Data.BuiltinPatterns + Vehicle.Data.BuiltinInterface.DSL + Vehicle.Data.BuiltinInterface.Expr + Vehicle.Data.BuiltinInterface.Value Vehicle.Data.DeBruijn Vehicle.Data.DSL Vehicle.Data.Hashing + Vehicle.Data.LinearExpr Vehicle.Data.NormalisedExpr Vehicle.Export Vehicle.Libraries @@ -188,6 +182,7 @@ library Vehicle.Backend.LossFunction.TypeSystem.InstanceDefaults Vehicle.Backend.LossFunction.TypeSystem.Type Vehicle.Backend.Queries + Vehicle.Backend.Queries.ConstraintSearch Vehicle.Backend.Queries.Error.Linearity Vehicle.Backend.Queries.Error.Linearity.AnnotationRestrictions Vehicle.Backend.Queries.Error.Linearity.Core @@ -198,7 +193,14 @@ library Vehicle.Backend.Queries.Error.Polarity.Core Vehicle.Backend.Queries.Error.Polarity.PolaritySolver Vehicle.Backend.Queries.Error.Polarity.Type - Vehicle.Backend.Queries.UsedFunctions + Vehicle.Backend.Queries.PostProcessing + Vehicle.Backend.Queries.UserVariableElimination + Vehicle.Backend.Queries.UserVariableElimination.Core + Vehicle.Backend.Queries.UserVariableElimination.EliminateExists + Vehicle.Backend.Queries.UserVariableElimination.EliminateNot + Vehicle.Backend.Queries.UserVariableElimination.FourierMotzkinElimination + Vehicle.Backend.Queries.UserVariableElimination.Unblocking + Vehicle.Backend.Queries.UserVariableElimination.VariableReconstruction Vehicle.Compile.Arity Vehicle.Compile.Context.Bound.Class Vehicle.Compile.Context.Bound.Core @@ -258,6 +260,7 @@ library Vehicle.Verify.Specification Vehicle.Verify.Specification.IO Vehicle.Verify.Specification.Status + Vehicle.Verify.Variable Vehicle.Verify.Verifier.Core Vehicle.Verify.Verifier.Marabou @@ -300,8 +303,9 @@ executable vehicle main-is: Main.hs hs-source-dirs: app build-depends: - , base >=4.13 && <5 - , optparse-applicative >=0.16 && <1 + , base + , optparse-applicative + , text , vehicle -----------------