diff --git a/bin/alk.jar b/bin/alk.jar index 4e0edc8b..61e796e4 100644 Binary files a/bin/alk.jar and b/bin/alk.jar differ diff --git a/bin/alki.bat b/bin/alki.bat index 5025f271..fcf94c1a 100644 --- a/bin/alki.bat +++ b/bin/alki.bat @@ -1 +1,2 @@ -java -jar "%~dp0\alk.jar" %* +set PATH=%PATH%;%~dp0\lib +java -Djava-library-path="%~dp0;%~dp0\lib" -cp "%~dp0\alk.jar;%~dp0\lib\com.microsoft.z3.jar" main.ExecutionDriver %* diff --git a/bin/alki.out b/bin/alki.out deleted file mode 100644 index 3bce928a..00000000 Binary files a/bin/alki.out and /dev/null differ diff --git a/bin/alki.sh b/bin/alki.sh index 394d7aba..e4e2a8fe 100755 --- a/bin/alki.sh +++ b/bin/alki.sh @@ -1,4 +1,4 @@ -#!/bin/bash + #!/bin/bash TARGET_FILE=$0 ORIG=`pwd -P` @@ -19,5 +19,8 @@ done # for the directory we're in and appending the target file. PHYS_DIR=`pwd -P` cd "$ORIG" -java -jar $PHYS_DIR/alk.jar "${@:1}" +export PATH="$PATH:$PHYS_DIR:$PHYS_DIR/lib" +export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$PHYS_DIR:$PHYS_DIR/lib" +export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:$PHYS_DIR:$PHYS_DIR/lib" +java -Djava.library.path="$PHYS_DIR:$PHYS_DIR/lib" -cp "$PHYS_DIR/alk.jar:$PHYS_DIR/lib/com.microsoft.z3.jar" main.ExecutionDriver "${@:1}" exit 0 diff --git a/bin/arrays.alk b/bin/arrays.alk deleted file mode 100644 index f4e6e0af..00000000 --- a/bin/arrays.alk +++ /dev/null @@ -1,10 +0,0 @@ -/* - arrays - line 1 uncommented: alki arrays.alk -*/ -a = [3, 5, 6, 4]; -i = 1; -x = a[i]; -a[i+1] = x; -print(x); // 5 -print(a); // [3, 5, 5, 4] diff --git a/bin/example.alk b/bin/example.alk deleted file mode 100644 index 313fd6a2..00000000 --- a/bin/example.alk +++ /dev/null @@ -1,2 +0,0 @@ -x = 1; -y = 2; \ No newline at end of file diff --git a/bin/lib/Microsoft.Z3.deps.json b/bin/lib/Microsoft.Z3.deps.json new file mode 100644 index 00000000..e4b37798 --- /dev/null +++ b/bin/lib/Microsoft.Z3.deps.json @@ -0,0 +1,1047 @@ +{ + "runtimeTarget": { + "name": ".NETStandard,Version=v1.4/", + "signature": "" + }, + "compilationOptions": {}, + "targets": { + ".NETStandard,Version=v1.4": {}, + ".NETStandard,Version=v1.4/": { + "Microsoft.Z3/4.8.14": { + "dependencies": { + "NETStandard.Library": "1.6.1" + }, + "runtime": { + "Microsoft.Z3.dll": {} + } + }, + "Microsoft.NETCore.Platforms/1.1.0": {}, + "Microsoft.NETCore.Targets/1.1.0": {}, + "Microsoft.Win32.Primitives/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "NETStandard.Library/1.6.1": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.Win32.Primitives": "4.3.0", + "System.AppContext": "4.3.0", + "System.Collections": "4.3.0", + "System.Collections.Concurrent": "4.3.0", + "System.Console": "4.3.0", + "System.Diagnostics.Debug": "4.3.0", + "System.Diagnostics.Tools": "4.3.0", + "System.Diagnostics.Tracing": "4.3.0", + "System.Globalization": "4.3.0", + "System.Globalization.Calendars": "4.3.0", + "System.IO": "4.3.0", + "System.IO.Compression": "4.3.0", + "System.IO.Compression.ZipFile": "4.3.0", + "System.IO.FileSystem": "4.3.0", + "System.IO.FileSystem.Primitives": "4.3.0", + "System.Linq": "4.3.0", + "System.Linq.Expressions": "4.3.0", + "System.Net.Http": "4.3.0", + "System.Net.Primitives": "4.3.0", + "System.Net.Sockets": "4.3.0", + "System.ObjectModel": "4.3.0", + "System.Reflection": "4.3.0", + "System.Reflection.Extensions": "4.3.0", + "System.Reflection.Primitives": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Runtime.Handles": "4.3.0", + "System.Runtime.InteropServices": "4.3.0", + "System.Runtime.InteropServices.RuntimeInformation": "4.3.0", + "System.Runtime.Numerics": "4.3.0", + "System.Security.Cryptography.Algorithms": "4.3.0", + "System.Security.Cryptography.Encoding": "4.3.0", + "System.Security.Cryptography.Primitives": "4.3.0", + "System.Security.Cryptography.X509Certificates": "4.3.0", + "System.Text.Encoding": "4.3.0", + "System.Text.Encoding.Extensions": "4.3.0", + "System.Text.RegularExpressions": "4.3.0", + "System.Threading": "4.3.0", + "System.Threading.Tasks": "4.3.0", + "System.Threading.Timer": "4.3.0", + "System.Xml.ReaderWriter": "4.3.0", + "System.Xml.XDocument": "4.3.0" + } + }, + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.native.System/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" + } + }, + "runtime.native.System.IO.Compression/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" + } + }, + "runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "dependencies": { + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0", + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": {}, + "System.AppContext/4.3.0": { + "dependencies": { + "System.Runtime": "4.3.0" + } + }, + "System.Buffers/4.3.0": { + "dependencies": { + "System.Diagnostics.Debug": "4.3.0", + "System.Diagnostics.Tracing": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Threading": "4.3.0" + }, + "runtime": { + "lib/netstandard1.1/System.Buffers.dll": { + "assemblyVersion": "4.0.1.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Collections/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Collections.Concurrent/4.3.0": { + "dependencies": { + "System.Collections": "4.3.0", + "System.Diagnostics.Debug": "4.3.0", + "System.Diagnostics.Tracing": "4.3.0", + "System.Globalization": "4.3.0", + "System.Reflection": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Threading": "4.3.0", + "System.Threading.Tasks": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.Collections.Concurrent.dll": { + "assemblyVersion": "4.0.13.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Console/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.IO": "4.3.0", + "System.Runtime": "4.3.0", + "System.Text.Encoding": "4.3.0" + } + }, + "System.Diagnostics.Debug/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Diagnostics.DiagnosticSource/4.3.0": { + "dependencies": { + "System.Collections": "4.3.0", + "System.Diagnostics.Tracing": "4.3.0", + "System.Reflection": "4.3.0", + "System.Runtime": "4.3.0", + "System.Threading": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.Diagnostics.DiagnosticSource.dll": { + "assemblyVersion": "4.0.1.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Diagnostics.Tools/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Diagnostics.Tracing/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Globalization/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Globalization.Calendars/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Globalization": "4.3.0", + "System.Runtime": "4.3.0" + } + }, + "System.IO/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0", + "System.Text.Encoding": "4.3.0", + "System.Threading.Tasks": "4.3.0" + } + }, + "System.IO.Compression/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "System.Buffers": "4.3.0", + "System.Collections": "4.3.0", + "System.Diagnostics.Debug": "4.3.0", + "System.IO": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Runtime.Handles": "4.3.0", + "System.Runtime.InteropServices": "4.3.0", + "System.Text.Encoding": "4.3.0", + "System.Threading": "4.3.0", + "System.Threading.Tasks": "4.3.0", + "runtime.native.System": "4.3.0", + "runtime.native.System.IO.Compression": "4.3.0" + } + }, + "System.IO.Compression.ZipFile/4.3.0": { + "dependencies": { + "System.Buffers": "4.3.0", + "System.IO": "4.3.0", + "System.IO.Compression": "4.3.0", + "System.IO.FileSystem": "4.3.0", + "System.IO.FileSystem.Primitives": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Text.Encoding": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.IO.Compression.ZipFile.dll": { + "assemblyVersion": "4.0.2.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.IO.FileSystem/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.IO": "4.3.0", + "System.IO.FileSystem.Primitives": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Handles": "4.3.0", + "System.Text.Encoding": "4.3.0", + "System.Threading.Tasks": "4.3.0" + } + }, + "System.IO.FileSystem.Primitives/4.3.0": { + "dependencies": { + "System.Runtime": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.IO.FileSystem.Primitives.dll": { + "assemblyVersion": "4.0.2.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Linq/4.3.0": { + "dependencies": { + "System.Collections": "4.3.0", + "System.Runtime": "4.3.0" + } + }, + "System.Linq.Expressions/4.3.0": { + "dependencies": { + "System.Reflection": "4.3.0", + "System.Runtime": "4.3.0" + } + }, + "System.Net.Http/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.Win32.Primitives": "4.3.0", + "System.Collections": "4.3.0", + "System.Diagnostics.Debug": "4.3.0", + "System.Diagnostics.DiagnosticSource": "4.3.0", + "System.Diagnostics.Tracing": "4.3.0", + "System.Globalization": "4.3.0", + "System.IO": "4.3.0", + "System.IO.Compression": "4.3.0", + "System.Net.Primitives": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Runtime.Handles": "4.3.0", + "System.Runtime.InteropServices": "4.3.0", + "System.Security.Cryptography.X509Certificates": "4.3.0", + "System.Text.Encoding": "4.3.0", + "System.Threading": "4.3.0", + "System.Threading.Tasks": "4.3.0" + } + }, + "System.Net.Primitives/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0", + "System.Runtime.Handles": "4.3.0" + } + }, + "System.Net.Sockets/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.IO": "4.3.0", + "System.Net.Primitives": "4.3.0", + "System.Runtime": "4.3.0", + "System.Threading.Tasks": "4.3.0" + } + }, + "System.ObjectModel/4.3.0": { + "dependencies": { + "System.Collections": "4.3.0", + "System.Diagnostics.Debug": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Threading": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.ObjectModel.dll": { + "assemblyVersion": "4.0.13.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Reflection/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.IO": "4.3.0", + "System.Reflection.Primitives": "4.3.0", + "System.Runtime": "4.3.0" + } + }, + "System.Reflection.Extensions/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Reflection": "4.3.0", + "System.Runtime": "4.3.0" + } + }, + "System.Reflection.Primitives/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Resources.ResourceManager/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Globalization": "4.3.0", + "System.Reflection": "4.3.0", + "System.Runtime": "4.3.0" + } + }, + "System.Runtime/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0" + } + }, + "System.Runtime.Extensions/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Runtime.Handles/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Runtime.InteropServices/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Reflection": "4.3.0", + "System.Reflection.Primitives": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Handles": "4.3.0" + } + }, + "System.Runtime.InteropServices.RuntimeInformation/4.3.0": { + "dependencies": { + "System.Reflection": "4.3.0", + "System.Reflection.Extensions": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.InteropServices": "4.3.0", + "System.Threading": "4.3.0", + "runtime.native.System": "4.3.0" + }, + "runtime": { + "lib/netstandard1.1/System.Runtime.InteropServices.RuntimeInformation.dll": { + "assemblyVersion": "4.0.1.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Runtime.Numerics/4.3.0": { + "dependencies": { + "System.Globalization": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.Runtime.Numerics.dll": { + "assemblyVersion": "4.0.2.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Security.Cryptography.Algorithms/4.3.0": { + "dependencies": { + "System.IO": "4.3.0", + "System.Runtime": "4.3.0", + "System.Security.Cryptography.Primitives": "4.3.0" + } + }, + "System.Security.Cryptography.Encoding/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "System.Collections": "4.3.0", + "System.Collections.Concurrent": "4.3.0", + "System.Linq": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Runtime.Handles": "4.3.0", + "System.Runtime.InteropServices": "4.3.0", + "System.Security.Cryptography.Primitives": "4.3.0", + "System.Text.Encoding": "4.3.0", + "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0" + } + }, + "System.Security.Cryptography.Primitives/4.3.0": { + "dependencies": { + "System.Diagnostics.Debug": "4.3.0", + "System.Globalization": "4.3.0", + "System.IO": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Threading": "4.3.0", + "System.Threading.Tasks": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.Security.Cryptography.Primitives.dll": { + "assemblyVersion": "4.0.1.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Security.Cryptography.X509Certificates/4.3.0": { + "dependencies": { + "System.Runtime": "4.3.0", + "System.Runtime.Handles": "4.3.0", + "System.Security.Cryptography.Algorithms": "4.3.0", + "System.Security.Cryptography.Encoding": "4.3.0" + } + }, + "System.Text.Encoding/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Text.Encoding.Extensions/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0", + "System.Text.Encoding": "4.3.0" + } + }, + "System.Text.RegularExpressions/4.3.0": { + "dependencies": { + "System.Runtime": "4.3.0" + } + }, + "System.Threading/4.3.0": { + "dependencies": { + "System.Runtime": "4.3.0", + "System.Threading.Tasks": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.Threading.dll": { + "assemblyVersion": "4.0.12.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Threading.Tasks/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Threading.Tasks.Extensions/4.3.0": { + "dependencies": { + "System.Collections": "4.3.0", + "System.Runtime": "4.3.0", + "System.Threading.Tasks": "4.3.0" + }, + "runtime": { + "lib/netstandard1.0/System.Threading.Tasks.Extensions.dll": { + "assemblyVersion": "4.1.0.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Threading.Timer/4.3.0": { + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.NETCore.Targets": "1.1.0", + "System.Runtime": "4.3.0" + } + }, + "System.Xml.ReaderWriter/4.3.0": { + "dependencies": { + "System.Collections": "4.3.0", + "System.Diagnostics.Debug": "4.3.0", + "System.Globalization": "4.3.0", + "System.IO": "4.3.0", + "System.IO.FileSystem": "4.3.0", + "System.IO.FileSystem.Primitives": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Runtime.InteropServices": "4.3.0", + "System.Text.Encoding": "4.3.0", + "System.Text.Encoding.Extensions": "4.3.0", + "System.Text.RegularExpressions": "4.3.0", + "System.Threading.Tasks": "4.3.0", + "System.Threading.Tasks.Extensions": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.Xml.ReaderWriter.dll": { + "assemblyVersion": "4.1.0.0", + "fileVersion": "4.6.24705.1" + } + } + }, + "System.Xml.XDocument/4.3.0": { + "dependencies": { + "System.Collections": "4.3.0", + "System.Diagnostics.Debug": "4.3.0", + "System.Diagnostics.Tools": "4.3.0", + "System.Globalization": "4.3.0", + "System.IO": "4.3.0", + "System.Reflection": "4.3.0", + "System.Resources.ResourceManager": "4.3.0", + "System.Runtime": "4.3.0", + "System.Runtime.Extensions": "4.3.0", + "System.Text.Encoding": "4.3.0", + "System.Threading": "4.3.0", + "System.Xml.ReaderWriter": "4.3.0" + }, + "runtime": { + "lib/netstandard1.3/System.Xml.XDocument.dll": { + "assemblyVersion": "4.0.12.0", + "fileVersion": "4.6.24705.1" + } + } + } + } + }, + "libraries": { + "Microsoft.Z3/4.8.14": { + "type": "project", + "serviceable": false, + "sha512": "" + }, + "Microsoft.NETCore.Platforms/1.1.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==", + "path": "microsoft.netcore.platforms/1.1.0", + "hashPath": "microsoft.netcore.platforms.1.1.0.nupkg.sha512" + }, + "Microsoft.NETCore.Targets/1.1.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-aOZA3BWfz9RXjpzt0sRJJMjAscAUm3Hoa4UWAfceV9UTYxgwZ1lZt5nO2myFf+/jetYQo4uTP7zS8sJY67BBxg==", + "path": "microsoft.netcore.targets/1.1.0", + "hashPath": "microsoft.netcore.targets.1.1.0.nupkg.sha512" + }, + "Microsoft.Win32.Primitives/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-9ZQKCWxH7Ijp9BfahvL2Zyf1cJIk8XYLF6Yjzr2yi0b2cOut/HQ31qf1ThHAgCc3WiZMdnWcfJCgN82/0UunxA==", + "path": "microsoft.win32.primitives/4.3.0", + "hashPath": "microsoft.win32.primitives.4.3.0.nupkg.sha512" + }, + "NETStandard.Library/1.6.1": { + "type": "package", + "serviceable": true, + "sha512": "sha512-WcSp3+vP+yHNgS8EV5J7pZ9IRpeDuARBPN28by8zqff1wJQXm26PVU8L3/fYLBJVU7BtDyqNVWq2KlCVvSSR4A==", + "path": "netstandard.library/1.6.1", + "hashPath": "netstandard.library.1.6.1.nupkg.sha512" + }, + "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-HdSSp5MnJSsg08KMfZThpuLPJpPwE5hBXvHwoKWosyHHfe8Mh5WKT0ylEOf6yNzX6Ngjxe4Whkafh5q7Ymac4Q==", + "path": "runtime.debian.8-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.debian.8-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-+yH1a49wJMy8Zt4yx5RhJrxO/DBDByAiCzNwiETI+1S4mPdCu0OY4djdciC7Vssk0l22wQaDLrXxXkp+3+7bVA==", + "path": "runtime.fedora.23-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.fedora.23-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-c3YNH1GQJbfIPJeCnr4avseugSqPrxwIqzthYyZDN6EuOyNOzq+y2KSUfRcXauya1sF4foESTgwM5e1A8arAKw==", + "path": "runtime.fedora.24-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.fedora.24-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.native.System/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-c/qWt2LieNZIj1jGnVNsE2Kl23Ya2aSTBuXMD6V7k9KWr6l16Tqdwq+hJScEpWER9753NWC8h96PaVNY5Ld7Jw==", + "path": "runtime.native.system/4.3.0", + "hashPath": "runtime.native.system.4.3.0.nupkg.sha512" + }, + "runtime.native.System.IO.Compression/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-INBPonS5QPEgn7naufQFXJEp3zX6L4bwHgJ/ZH78aBTpeNfQMtf7C6VrAFhlq2xxWBveIOWyFzQjJ8XzHMhdOQ==", + "path": "runtime.native.system.io.compression/4.3.0", + "hashPath": "runtime.native.system.io.compression.4.3.0.nupkg.sha512" + }, + "runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-NS1U+700m4KFRHR5o4vo9DSlTmlCKu/u7dtE5sUHVIPB+xpXxYQvgBgA6wEIeCz6Yfn0Z52/72WYsToCEPJnrw==", + "path": "runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-b3pthNgxxFcD+Pc0WSEoC0+md3MyhRS6aCEeenvNE3Fdw1HyJ18ZhRFVJJzIeR/O/jpxPboB805Ho0T3Ul7w8A==", + "path": "runtime.opensuse.13.2-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.opensuse.13.2-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-KeLz4HClKf+nFS7p/6Fi/CqyLXh81FpiGzcmuS8DGi9lUqSnZ6Es23/gv2O+1XVGfrbNmviF7CckBpavkBoIFQ==", + "path": "runtime.opensuse.42.1-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.opensuse.42.1-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-X7IdhILzr4ROXd8mI1BUCQMSHSQwelUlBjF1JyTKCjXaOGn2fB4EKBxQbCK2VjO3WaWIdlXZL3W6TiIVnrhX4g==", + "path": "runtime.osx.10.10-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.osx.10.10-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-nyFNiCk/r+VOiIqreLix8yN+q3Wga9+SE8BCgkf+2BwEKiNx6DyvFjCgkfV743/grxv8jHJ8gUK4XEQw7yzRYg==", + "path": "runtime.rhel.7-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.rhel.7-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-ytoewC6wGorL7KoCAvRfsgoJPJbNq+64k2SqW6JcOAebWsFUvCCYgfzQMrnpvPiEl4OrblUlhF2ji+Q1+SVLrQ==", + "path": "runtime.ubuntu.14.04-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.ubuntu.14.04-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-I8bKw2I8k58Wx7fMKQJn2R8lamboCAiHfHeV/pS65ScKWMMI0+wJkLYlEKvgW1D/XvSl/221clBoR2q9QNNM7A==", + "path": "runtime.ubuntu.16.04-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.ubuntu.16.04-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-VB5cn/7OzUfzdnC8tqAIMQciVLiq2epm2NrAm1E9OjNRyG4lVhfR61SMcLizejzQP8R8Uf/0l5qOIbUEi+RdEg==", + "path": "runtime.ubuntu.16.10-x64.runtime.native.system.security.cryptography.openssl/4.3.0", + "hashPath": "runtime.ubuntu.16.10-x64.runtime.native.system.security.cryptography.openssl.4.3.0.nupkg.sha512" + }, + "System.AppContext/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-fKC+rmaLfeIzUhagxY17Q9siv/sPrjjKcfNg1Ic8IlQkZLipo8ljcaZQu4VtI4Jqbzjc2VTjzGLF6WmsRXAEgA==", + "path": "system.appcontext/4.3.0", + "hashPath": "system.appcontext.4.3.0.nupkg.sha512" + }, + "System.Buffers/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-ratu44uTIHgeBeI0dE8DWvmXVBSo4u7ozRZZHOMmK/JPpYyo0dAfgSiHlpiObMQ5lEtEyIXA40sKRYg5J6A8uQ==", + "path": "system.buffers/4.3.0", + "hashPath": "system.buffers.4.3.0.nupkg.sha512" + }, + "System.Collections/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-3Dcj85/TBdVpL5Zr+gEEBUuFe2icOnLalmEh9hfck1PTYbbyWuZgh4fmm2ysCLTrqLQw6t3TgTyJ+VLp+Qb+Lw==", + "path": "system.collections/4.3.0", + "hashPath": "system.collections.4.3.0.nupkg.sha512" + }, + "System.Collections.Concurrent/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-ztl69Xp0Y/UXCL+3v3tEU+lIy+bvjKNUmopn1wep/a291pVPK7dxBd6T7WnlQqRog+d1a/hSsgRsmFnIBKTPLQ==", + "path": "system.collections.concurrent/4.3.0", + "hashPath": "system.collections.concurrent.4.3.0.nupkg.sha512" + }, + "System.Console/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-DHDrIxiqk1h03m6khKWV2X8p/uvN79rgSqpilL6uzpmSfxfU5ng8VcPtW4qsDsQDHiTv6IPV9TmD5M/vElPNLg==", + "path": "system.console/4.3.0", + "hashPath": "system.console.4.3.0.nupkg.sha512" + }, + "System.Diagnostics.Debug/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-ZUhUOdqmaG5Jk3Xdb8xi5kIyQYAA4PnTNlHx1mu9ZY3qv4ELIdKbnL/akbGaKi2RnNUWaZsAs31rvzFdewTj2g==", + "path": "system.diagnostics.debug/4.3.0", + "hashPath": "system.diagnostics.debug.4.3.0.nupkg.sha512" + }, + "System.Diagnostics.DiagnosticSource/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-tD6kosZnTAGdrEa0tZSuFyunMbt/5KYDnHdndJYGqZoNy00XVXyACd5d6KnE1YgYv3ne2CjtAfNXo/fwEhnKUA==", + "path": "system.diagnostics.diagnosticsource/4.3.0", + "hashPath": "system.diagnostics.diagnosticsource.4.3.0.nupkg.sha512" + }, + "System.Diagnostics.Tools/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-UUvkJfSYJMM6x527dJg2VyWPSRqIVB0Z7dbjHst1zmwTXz5CcXSYJFWRpuigfbO1Lf7yfZiIaEUesfnl/g5EyA==", + "path": "system.diagnostics.tools/4.3.0", + "hashPath": "system.diagnostics.tools.4.3.0.nupkg.sha512" + }, + "System.Diagnostics.Tracing/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-rswfv0f/Cqkh78rA5S8eN8Neocz234+emGCtTF3lxPY96F+mmmUen6tbn0glN6PMvlKQb9bPAY5e9u7fgPTkKw==", + "path": "system.diagnostics.tracing/4.3.0", + "hashPath": "system.diagnostics.tracing.4.3.0.nupkg.sha512" + }, + "System.Globalization/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-kYdVd2f2PAdFGblzFswE4hkNANJBKRmsfa2X5LG2AcWE1c7/4t0pYae1L8vfZ5xvE2nK/R9JprtToA61OSHWIg==", + "path": "system.globalization/4.3.0", + "hashPath": "system.globalization.4.3.0.nupkg.sha512" + }, + "System.Globalization.Calendars/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-GUlBtdOWT4LTV3I+9/PJW+56AnnChTaOqqTLFtdmype/L500M2LIyXgmtd9X2P2VOkmJd5c67H5SaC2QcL1bFA==", + "path": "system.globalization.calendars/4.3.0", + "hashPath": "system.globalization.calendars.4.3.0.nupkg.sha512" + }, + "System.IO/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-3qjaHvxQPDpSOYICjUoTsmoq5u6QJAFRUITgeT/4gqkF1bajbSmb1kwSxEA8AHlofqgcKJcM8udgieRNhaJ5Cg==", + "path": "system.io/4.3.0", + "hashPath": "system.io.4.3.0.nupkg.sha512" + }, + "System.IO.Compression/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-YHndyoiV90iu4iKG115ibkhrG+S3jBm8Ap9OwoUAzO5oPDAWcr0SFwQFm0HjM8WkEZWo0zvLTyLmbvTkW1bXgg==", + "path": "system.io.compression/4.3.0", + "hashPath": "system.io.compression.4.3.0.nupkg.sha512" + }, + "System.IO.Compression.ZipFile/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-G4HwjEsgIwy3JFBduZ9quBkAu+eUwjIdJleuNSgmUojbH6O3mlvEIme+GHx/cLlTAPcrnnL7GqvB9pTlWRfhOg==", + "path": "system.io.compression.zipfile/4.3.0", + "hashPath": "system.io.compression.zipfile.4.3.0.nupkg.sha512" + }, + "System.IO.FileSystem/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-3wEMARTnuio+ulnvi+hkRNROYwa1kylvYahhcLk4HSoVdl+xxTFVeVlYOfLwrDPImGls0mDqbMhrza8qnWPTdA==", + "path": "system.io.filesystem/4.3.0", + "hashPath": "system.io.filesystem.4.3.0.nupkg.sha512" + }, + "System.IO.FileSystem.Primitives/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-6QOb2XFLch7bEc4lIcJH49nJN2HV+OC3fHDgsLVsBVBk3Y4hFAnOBGzJ2lUu7CyDDFo9IBWkSsnbkT6IBwwiMw==", + "path": "system.io.filesystem.primitives/4.3.0", + "hashPath": "system.io.filesystem.primitives.4.3.0.nupkg.sha512" + }, + "System.Linq/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-5DbqIUpsDp0dFftytzuMmc0oeMdQwjcP/EWxsksIz/w1TcFRkZ3yKKz0PqiYFMmEwPSWw+qNVqD7PJ889JzHbw==", + "path": "system.linq/4.3.0", + "hashPath": "system.linq.4.3.0.nupkg.sha512" + }, + "System.Linq.Expressions/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-PGKkrd2khG4CnlyJwxwwaWWiSiWFNBGlgXvJpeO0xCXrZ89ODrQ6tjEWS/kOqZ8GwEOUATtKtzp1eRgmYNfclg==", + "path": "system.linq.expressions/4.3.0", + "hashPath": "system.linq.expressions.4.3.0.nupkg.sha512" + }, + "System.Net.Http/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-sYg+FtILtRQuYWSIAuNOELwVuVsxVyJGWQyOnlAzhV4xvhyFnON1bAzYYC+jjRW8JREM45R0R5Dgi8MTC5sEwA==", + "path": "system.net.http/4.3.0", + "hashPath": "system.net.http.4.3.0.nupkg.sha512" + }, + "System.Net.Primitives/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-qOu+hDwFwoZPbzPvwut2qATe3ygjeQBDQj91xlsaqGFQUI5i4ZnZb8yyQuLGpDGivEPIt8EJkd1BVzVoP31FXA==", + "path": "system.net.primitives/4.3.0", + "hashPath": "system.net.primitives.4.3.0.nupkg.sha512" + }, + "System.Net.Sockets/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-m6icV6TqQOAdgt5N/9I5KNpjom/5NFtkmGseEH+AK/hny8XrytLH3+b5M8zL/Ycg3fhIocFpUMyl/wpFnVRvdw==", + "path": "system.net.sockets/4.3.0", + "hashPath": "system.net.sockets.4.3.0.nupkg.sha512" + }, + "System.ObjectModel/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-bdX+80eKv9bN6K4N+d77OankKHGn6CH711a6fcOpMQu2Fckp/Ft4L/kW9WznHpyR0NRAvJutzOMHNNlBGvxQzQ==", + "path": "system.objectmodel/4.3.0", + "hashPath": "system.objectmodel.4.3.0.nupkg.sha512" + }, + "System.Reflection/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-KMiAFoW7MfJGa9nDFNcfu+FpEdiHpWgTcS2HdMpDvt9saK3y/G4GwprPyzqjFH9NTaGPQeWNHU+iDlDILj96aQ==", + "path": "system.reflection/4.3.0", + "hashPath": "system.reflection.4.3.0.nupkg.sha512" + }, + "System.Reflection.Extensions/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-rJkrJD3kBI5B712aRu4DpSIiHRtr6QlfZSQsb0hYHrDCZORXCFjQfoipo2LaMUHoT9i1B7j7MnfaEKWDFmFQNQ==", + "path": "system.reflection.extensions/4.3.0", + "hashPath": "system.reflection.extensions.4.3.0.nupkg.sha512" + }, + "System.Reflection.Primitives/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-5RXItQz5As4xN2/YUDxdpsEkMhvw3e6aNveFXUn4Hl/udNTCNhnKp8lT9fnc3MhvGKh1baak5CovpuQUXHAlIA==", + "path": "system.reflection.primitives/4.3.0", + "hashPath": "system.reflection.primitives.4.3.0.nupkg.sha512" + }, + "System.Resources.ResourceManager/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-/zrcPkkWdZmI4F92gL/TPumP98AVDu/Wxr3CSJGQQ+XN6wbRZcyfSKVoPo17ilb3iOr0cCRqJInGwNMolqhS8A==", + "path": "system.resources.resourcemanager/4.3.0", + "hashPath": "system.resources.resourcemanager.4.3.0.nupkg.sha512" + }, + "System.Runtime/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-JufQi0vPQ0xGnAczR13AUFglDyVYt4Kqnz1AZaiKZ5+GICq0/1MH/mO/eAJHt/mHW1zjKBJd7kV26SrxddAhiw==", + "path": "system.runtime/4.3.0", + "hashPath": "system.runtime.4.3.0.nupkg.sha512" + }, + "System.Runtime.Extensions/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-guW0uK0fn5fcJJ1tJVXYd7/1h5F+pea1r7FLSOz/f8vPEqbR2ZAknuRDvTQ8PzAilDveOxNjSfr0CHfIQfFk8g==", + "path": "system.runtime.extensions/4.3.0", + "hashPath": "system.runtime.extensions.4.3.0.nupkg.sha512" + }, + "System.Runtime.Handles/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-OKiSUN7DmTWeYb3l51A7EYaeNMnvxwE249YtZz7yooT4gOZhmTjIn48KgSsw2k2lYdLgTKNJw/ZIfSElwDRVgg==", + "path": "system.runtime.handles/4.3.0", + "hashPath": "system.runtime.handles.4.3.0.nupkg.sha512" + }, + "System.Runtime.InteropServices/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-uv1ynXqiMK8mp1GM3jDqPCFN66eJ5w5XNomaK2XD+TuCroNTLFGeZ+WCmBMcBDyTFKou3P6cR6J/QsaqDp7fGQ==", + "path": "system.runtime.interopservices/4.3.0", + "hashPath": "system.runtime.interopservices.4.3.0.nupkg.sha512" + }, + "System.Runtime.InteropServices.RuntimeInformation/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-cbz4YJMqRDR7oLeMRbdYv7mYzc++17lNhScCX0goO2XpGWdvAt60CGN+FHdePUEHCe/Jy9jUlvNAiNdM+7jsOw==", + "path": "system.runtime.interopservices.runtimeinformation/4.3.0", + "hashPath": "system.runtime.interopservices.runtimeinformation.4.3.0.nupkg.sha512" + }, + "System.Runtime.Numerics/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-yMH+MfdzHjy17l2KESnPiF2dwq7T+xLnSJar7slyimAkUh/gTrS9/UQOtv7xarskJ2/XDSNvfLGOBQPjL7PaHQ==", + "path": "system.runtime.numerics/4.3.0", + "hashPath": "system.runtime.numerics.4.3.0.nupkg.sha512" + }, + "System.Security.Cryptography.Algorithms/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-W1kd2Y8mYSCgc3ULTAZ0hOP2dSdG5YauTb1089T0/kRcN2MpSAW1izOFROrJgxSlMn3ArsgHXagigyi+ibhevg==", + "path": "system.security.cryptography.algorithms/4.3.0", + "hashPath": "system.security.cryptography.algorithms.4.3.0.nupkg.sha512" + }, + "System.Security.Cryptography.Encoding/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-1DEWjZZly9ae9C79vFwqaO5kaOlI5q+3/55ohmq/7dpDyDfc8lYe7YVxJUZ5MF/NtbkRjwFRo14yM4OEo9EmDw==", + "path": "system.security.cryptography.encoding/4.3.0", + "hashPath": "system.security.cryptography.encoding.4.3.0.nupkg.sha512" + }, + "System.Security.Cryptography.Primitives/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-7bDIyVFNL/xKeFHjhobUAQqSpJq9YTOpbEs6mR233Et01STBMXNAc/V+BM6dwYGc95gVh/Zf+iVXWzj3mE8DWg==", + "path": "system.security.cryptography.primitives/4.3.0", + "hashPath": "system.security.cryptography.primitives.4.3.0.nupkg.sha512" + }, + "System.Security.Cryptography.X509Certificates/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-t2Tmu6Y2NtJ2um0RtcuhP7ZdNNxXEgUm2JeoA/0NvlMjAhKCnM1NX07TDl3244mVp3QU6LPEhT3HTtH1uF7IYw==", + "path": "system.security.cryptography.x509certificates/4.3.0", + "hashPath": "system.security.cryptography.x509certificates.4.3.0.nupkg.sha512" + }, + "System.Text.Encoding/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-BiIg+KWaSDOITze6jGQynxg64naAPtqGHBwDrLaCtixsa5bKiR8dpPOHA7ge3C0JJQizJE+sfkz1wV+BAKAYZw==", + "path": "system.text.encoding/4.3.0", + "hashPath": "system.text.encoding.4.3.0.nupkg.sha512" + }, + "System.Text.Encoding.Extensions/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-YVMK0Bt/A43RmwizJoZ22ei2nmrhobgeiYwFzC4YAN+nue8RF6djXDMog0UCn+brerQoYVyaS+ghy9P/MUVcmw==", + "path": "system.text.encoding.extensions/4.3.0", + "hashPath": "system.text.encoding.extensions.4.3.0.nupkg.sha512" + }, + "System.Text.RegularExpressions/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-RpT2DA+L660cBt1FssIE9CAGpLFdFPuheB7pLpKpn6ZXNby7jDERe8Ua/Ne2xGiwLVG2JOqziiaVCGDon5sKFA==", + "path": "system.text.regularexpressions/4.3.0", + "hashPath": "system.text.regularexpressions.4.3.0.nupkg.sha512" + }, + "System.Threading/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-VkUS0kOBcUf3Wwm0TSbrevDDZ6BlM+b/HRiapRFWjM5O0NS0LviG0glKmFK+hhPDd1XFeSdU1GmlLhb2CoVpIw==", + "path": "system.threading/4.3.0", + "hashPath": "system.threading.4.3.0.nupkg.sha512" + }, + "System.Threading.Tasks/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-LbSxKEdOUhVe8BezB/9uOGGppt+nZf6e1VFyw6v3DN6lqitm0OSn2uXMOdtP0M3W4iMcqcivm2J6UgqiwwnXiA==", + "path": "system.threading.tasks/4.3.0", + "hashPath": "system.threading.tasks.4.3.0.nupkg.sha512" + }, + "System.Threading.Tasks.Extensions/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-npvJkVKl5rKXrtl1Kkm6OhOUaYGEiF9wFbppFRWSMoApKzt2PiPHT2Bb8a5sAWxprvdOAtvaARS9QYMznEUtug==", + "path": "system.threading.tasks.extensions/4.3.0", + "hashPath": "system.threading.tasks.extensions.4.3.0.nupkg.sha512" + }, + "System.Threading.Timer/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-Z6YfyYTCg7lOZjJzBjONJTFKGN9/NIYKSxhU5GRd+DTwHSZyvWp1xuI5aR+dLg+ayyC5Xv57KiY4oJ0tMO89fQ==", + "path": "system.threading.timer/4.3.0", + "hashPath": "system.threading.timer.4.3.0.nupkg.sha512" + }, + "System.Xml.ReaderWriter/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-GrprA+Z0RUXaR4N7/eW71j1rgMnEnEVlgii49GZyAjTH7uliMnrOU3HNFBr6fEDBCJCIdlVNq9hHbaDR621XBA==", + "path": "system.xml.readerwriter/4.3.0", + "hashPath": "system.xml.readerwriter.4.3.0.nupkg.sha512" + }, + "System.Xml.XDocument/4.3.0": { + "type": "package", + "serviceable": true, + "sha512": "sha512-5zJ0XDxAIg8iy+t4aMnQAu0MqVbqyvfoUVl1yDV61xdo3Vth45oA2FoY4pPkxYAH5f8ixpmTqXeEIya95x0aCQ==", + "path": "system.xml.xdocument/4.3.0", + "hashPath": "system.xml.xdocument.4.3.0.nupkg.sha512" + } + } +} \ No newline at end of file diff --git a/bin/Microsoft.Z3.dll b/bin/lib/Microsoft.Z3.dll similarity index 100% rename from bin/Microsoft.Z3.dll rename to bin/lib/Microsoft.Z3.dll diff --git a/bin/lib/Microsoft.Z3.xml b/bin/lib/Microsoft.Z3.xml new file mode 100644 index 00000000..cf086dc3 --- /dev/null +++ b/bin/lib/Microsoft.Z3.xml @@ -0,0 +1,7098 @@ + + + + Microsoft.Z3 + + + + + Algebraic numbers + + + + + Return a upper bound for a given real algebraic number. + The interval isolating the number is smaller than 1/10^. + + + the precision of the result + A numeral Expr of sort Real + + + + Return a lower bound for the given real algebraic number. + The interval isolating the number is smaller than 1/10^. + + + + A numeral Expr of sort Real + + + + Returns a string representation in decimal notation. + + The result has at most decimal places. + + + + ApplyResult objects represent the result of an application of a + tactic to a goal. It contains the subgoals that were produced. + + + + + The number of Subgoals. + + + + + Retrieves the subgoals from the ApplyResult. + + + + + A string representation of the ApplyResult. + + + + + Arithmetic expressions (int/real) + + + + Constructor for ArithExpr + + + Operator overloading for arithmetical division operator (over reals) + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + Operator overloading for arithmetical operator + + + + An arithmetic sort, i.e., Int or Real. + + + + + Array expressions + + + + Constructor for ArrayExpr + + + Single argument select + + + Multi argument select + + + + Array sorts. + + + + + The domain of the array sort. + + + + + The range of the array sort. + + + + + The abstract syntax tree (AST) class. + + + + + Comparison operator. + + An AST + An AST + True if and are from the same context + and represent the same sort; false otherwise. + + + + Comparison operator. + + An AST + An AST + True if and are not from the same context + or represent different sorts; false otherwise. + + + + Object comparison. + + + + + Object Comparison. + + Another AST + Negative if the object should be sorted before , positive if after else zero. + + + + The AST's hash code. + + A hash code + + + + A unique identifier for the AST (unique among all ASTs). + + + + + Translates (copies) the AST to the Context . + + A context + A copy of the AST which is associated with + + + + The kind of the AST. + + + + + Indicates whether the AST is an Expr + + + + + Indicates whether the AST is an application + + + + + Indicates whether the AST is a BoundVariable + + + + + Indicates whether the AST is a Quantifier + + + + + Indicates whether the AST is a Sort + + + + + Indicates whether the AST is a FunctionDeclaration + + + + + A string representation of the AST. + + + + + A string representation of the AST in s-expression notation. + + + + + Map from AST to AST + + + + + Checks whether the map contains the key . + + An AST + True if is a key in the map, false otherwise. + + + + Finds the value associated with the key . + + + This function signs an error when is not a key in the map. + + An AST + + + + Stores or replaces a new key/value pair in the map. + + The key AST + The value AST + + + + Erases the key from the map. + + An AST + + + + Removes all keys from the map. + + + + + The size of the map + + + + + The keys stored in the map. + + + + + Retrieves a string representation of the map. + + + + + Vectors of ASTs. + + + + + The size of the vector + + + + + Retrieves the i-th object in the vector. + + May throw an IndexOutOfBoundsException when is out of range. + Index + An AST + + + + Resize the vector to . + + The new size of the vector. + + + + Add the AST to the back of the vector. The size + is increased by 1. + + An AST + + + + Translates all ASTs in the vector to . + + A context + A new ASTVector + + + + Retrieves a string representation of the vector. + + + + + Translates an AST vector into an AST[] + + + + + Translates an ASTVector into an Expr[] + + + + + Translates an ASTVector into a BoolExpr[] + + + + + Translates an ASTVector into a BitVecExpr[] + + + + + Translates an ASTVector into a ArithExpr[] + + + + + Translates an ASTVector into a ArrayExpr[] + + + + + Translates an ASTVector into a DatatypeExpr[] + + + + + Translates an ASTVector into a FPExpr[] + + + + + Translates an ASTVector into a FPRMExpr[] + + + + + Translates an ASTVector into a IntExpr[] + + + + + Translates an ASTVector into a RealExpr[] + + + + + Bit-vector expressions + + + + + The size of the sort of a bit-vector term. + + + + Constructor for BitVecExpr + + + + Bit-vector numerals + + + + + Retrieve the 64-bit unsigned integer value. + + + + + Retrieve the int value. + + + + + Retrieve the 64-bit int value. + + + + + Retrieve the int value. + + + + + Retrieve the BigInteger value. + + + + + Returns a decimal string representation of the numeral. + + + + + Returns a binary string representation of the numeral. + + + + + Bit-vector sorts. + + + + + The size of the bit-vector sort. + + + + + Boolean expressions + + + + Constructor for BoolExpr + + + Disjunction of Boolean expressions + + + Conjunction of Boolean expressions + + + Xor of Boolean expressions + + + Negation + + + + A Boolean sort. + + + + + A Character sort + + + + + Constructors are used for datatype sorts. + + + + + The number of fields of the constructor. + + + + + The function declaration of the constructor. + + + + + The function declaration of the tester. + + + + + The function declarations of the accessors + + + + + Destructor. + + + + + Lists of constructors + + + + + Destructor. + + + + + The main interaction with Z3 happens via the Context. + + + + + Constructor. + + + + + Constructor. + + + The following parameters can be set: + - proof (Boolean) Enable proof generation + - debug_ref_count (Boolean) Enable debug support for Z3_ast reference counting + - trace (Boolean) Tracing support for VCC + - trace_file_name (String) Trace out file for VCC traces + - timeout (unsigned) default timeout (in milliseconds) used for solvers + - well_sorted_check type checker + - auto_config use heuristics to automatically select solver and configure it + - model model generation for solvers, this parameter can be overwritten when creating a solver + - model_validate validate models produced by solvers + - unsat_core unsat-core generation for solvers, this parameter can be overwritten when creating a solver + Note that in previous versions of Z3, this constructor was also used to set global and module parameters. + For this purpose we should now use + + + + + Creates a new symbol using an integer. + + + Not all integers can be passed to this function. + The legal range of unsigned integers is 0 to 2^30-1. + + + + + Create a symbol using a string. + + + + + Create an array of symbols. + + + + + Retrieves the Boolean sort of the context. + + + + + Retrieves the Integer sort of the context. + + + + + Retrieves the Real sort of the context. + + + + + Retrieves the String sort of the context. + + + + + Retrieves the String sort of the context. + + + + + Create a new Boolean sort. + + + + + Create a new uninterpreted sort. + + + + + Create a new uninterpreted sort. + + + + + Create a new integer sort. + + + + + Create a real sort. + + + + + Create a new bit-vector sort. + + + + + Create a new sequence sort. + + + + + Create a new regular expression sort. + + + + + Create a new array sort. + + + + + Create a new n-ary array sort. + + + + + Create a new tuple sort. + + + + + Create a new enumeration sort. + + + + + Create a new enumeration sort. + + + + + Create a new list sort. + + + + + Create a new list sort. + + + + + Create a new finite domain sort. + The result is a sort + + The name used to identify the sort + The size of the sort + + + + Create a new finite domain sort. + The result is a sort + Elements of the sort are created using , + and the elements range from 0 to size-1. + + The name used to identify the sort + The size of the sort + + + + Create a datatype constructor. + + constructor name + name of recognizer function. + names of the constructor fields. + field sorts, 0 if the field sort refers to a recursive sort. + reference to datatype sort that is an argument to the constructor; + if the corresponding sort reference is 0, then the value in sort_refs should be an index + referring to one of the recursive datatypes that is declared. + + + + Create a datatype constructor. + + + + + + + + + + + Create a new datatype sort. + + + + + Create a new datatype sort. + + + + + Create mutually recursive datatypes. + + names of datatype sorts + list of constructors, one list per sort. + + + + Create mutually recursive data-types. + + + + + + + + Update a datatype field at expression t with value v. + The function performs a record update at t. The field + that is passed in as argument is updated with value v, + the remaining fields of t are unchanged. + + + + + Creates a new function declaration. + + + + + Creates a new function declaration. + + + + + Creates a new function declaration. + + + + + Creates a new recursive function declaration. + + + + + Bind a definition to a recursive function declaration. + The function must have previously been created using + MkRecFuncDecl. The body may contain recursive uses of the function or + other mutually recursive functions. + + + + + Creates a new function declaration. + + + + + Creates a fresh function declaration with a name prefixed with . + + + + + + + Creates a new constant function declaration. + + + + + Creates a new constant function declaration. + + + + + Creates a fresh constant function declaration with a name prefixed with . + + + + + + + Creates a new bound variable. + + The de-Bruijn index of the variable + The sort of the variable + + + + Create a quantifier pattern. + + + + + Creates a new Constant of sort and named . + + + + + Creates a new Constant of sort and named . + + + + + Creates a fresh Constant of sort and a + name prefixed with . + + + + + Creates a fresh constant from the FuncDecl . + + A decl of a 0-arity function + + + + Create a Boolean constant. + + + + + Create a Boolean constant. + + + + + Creates an integer constant. + + + + + Creates an integer constant. + + + + + Creates a real constant. + + + + + Creates a real constant. + + + + + Creates a bit-vector constant. + + + + + Creates a bit-vector constant. + + + + + Create a new function application. + + + + + Create a new function application. + + + + + The true Term. + + + + + The false Term. + + + + + Creates a Boolean value. + + + + + Creates the equality = . + + + + + Creates a distinct term. + + + + + Mk an expression representing not(a). + + + + + Create an expression representing an if-then-else: ite(t1, t2, t3). + + An expression with Boolean sort + An expression + An expression with the same sort as + + + + Create an expression representing t1 iff t2. + + + + + Create an expression representing t1 -> t2. + + + + + Create an expression representing t1 xor t2. + + + + + Create an expression representing t1 xor t2 xor t3 ... . + + + + + Create an expression representing t[0] and t[1] and .... + + + + + Create an expression representing t[0] and t[1] and .... + + + + + Create an expression representing t[0] or t[1] or .... + + + + + Create an expression representing t[0] or t[1] or .... + + + + + Create an expression representing t[0] + t[1] + .... + + + + + Create an expression representing t[0] + t[1] + .... + + + + + Create an expression representing t[0] * t[1] * .... + + + + + Create an expression representing t[0] * t[1] * .... + + + + + Create an expression representing t[0] - t[1] - .... + + + + + Create an expression representing -t. + + + + + Create an expression representing t1 / t2. + + + + + Create an expression representing t1 mod t2. + + The arguments must have int type. + + + + Create an expression representing t1 rem t2. + + The arguments must have int type. + + + + Create an expression representing t1 ^ t2. + + + + + Create an expression representing t1 < t2 + + + + + Create an expression representing t1 <= t2 + + + + + Create an expression representing t1 > t2 + + + + + Create an expression representing t1 >= t2 + + + + + Coerce an integer to a real. + + + There is also a converse operation exposed. It follows the semantics prescribed by the SMT-LIB standard. + + You can take the floor of a real by creating an auxiliary integer Term k and + and asserting MakeInt2Real(k) <= t1 < MkInt2Real(k)+1. + The argument must be of integer sort. + + + + + Coerce a real to an integer. + + + The semantics of this function follows the SMT-LIB standard for the function to_int. + The argument must be of real sort. + + + + + Creates an expression that checks whether a real number is an integer. + + + + + Bitwise negation. + + The argument must have a bit-vector sort. + + + + Take conjunction of bits in a vector, return vector of length 1. + + The argument must have a bit-vector sort. + + + + Take disjunction of bits in a vector, return vector of length 1. + + The argument must have a bit-vector sort. + + + + Bitwise conjunction. + + The arguments must have a bit-vector sort. + + + + Bitwise disjunction. + + The arguments must have a bit-vector sort. + + + + Bitwise XOR. + + The arguments must have a bit-vector sort. + + + + Bitwise NAND. + + The arguments must have a bit-vector sort. + + + + Bitwise NOR. + + The arguments must have a bit-vector sort. + + + + Bitwise XNOR. + + The arguments must have a bit-vector sort. + + + + Standard two's complement unary minus. + + The arguments must have a bit-vector sort. + + + + Two's complement addition. + + The arguments must have the same bit-vector sort. + + + + Two's complement subtraction. + + The arguments must have the same bit-vector sort. + + + + Two's complement multiplication. + + The arguments must have the same bit-vector sort. + + + + Unsigned division. + + + It is defined as the floor of t1/t2 if \c t2 is + different from zero. If t2 is zero, then the result + is undefined. + The arguments must have the same bit-vector sort. + + + + + Signed division. + + + It is defined in the following way: + + - The \c floor of t1/t2 if \c t2 is different from zero, and t1*t2 >= 0. + + - The \c ceiling of t1/t2 if \c t2 is different from zero, and t1*t2 < 0. + + If t2 is zero, then the result is undefined. + The arguments must have the same bit-vector sort. + + + + + Unsigned remainder. + + + It is defined as t1 - (t1 /u t2) * t2, where /u represents unsigned division. + If t2 is zero, then the result is undefined. + The arguments must have the same bit-vector sort. + + + + + Signed remainder. + + + It is defined as t1 - (t1 /s t2) * t2, where /s represents signed division. + The most significant bit (sign) of the result is equal to the most significant bit of \c t1. + + If t2 is zero, then the result is undefined. + The arguments must have the same bit-vector sort. + + + + + Two's complement signed remainder (sign follows divisor). + + + If t2 is zero, then the result is undefined. + The arguments must have the same bit-vector sort. + + + + + Unsigned less-than + + + The arguments must have the same bit-vector sort. + + + + + Two's complement signed less-than + + + The arguments must have the same bit-vector sort. + + + + + Unsigned less-than or equal to. + + + The arguments must have the same bit-vector sort. + + + + + Two's complement signed less-than or equal to. + + + The arguments must have the same bit-vector sort. + + + + + Unsigned greater than or equal to. + + + The arguments must have the same bit-vector sort. + + + + + Two's complement signed greater than or equal to. + + + The arguments must have the same bit-vector sort. + + + + + Unsigned greater-than. + + + The arguments must have the same bit-vector sort. + + + + + Two's complement signed greater-than. + + + The arguments must have the same bit-vector sort. + + + + + Bit-vector concatenation. + + + The arguments must have a bit-vector sort. + + + The result is a bit-vector of size n1+n2, where n1 (n2) + is the size of t1 (t2). + + + + + Bit-vector extraction. + + + Extract the bits down to from a bitvector of + size m to yield a new bitvector of size n, where + n = high - low + 1. + The argument must have a bit-vector sort. + + + + + Bit-vector sign extension. + + + Sign-extends the given bit-vector to the (signed) equivalent bitvector of + size m+i, where \c m is the size of the given bit-vector. + The argument must have a bit-vector sort. + + + + + Bit-vector zero extension. + + + Extend the given bit-vector with zeros to the (unsigned) equivalent + bitvector of size m+i, where \c m is the size of the + given bit-vector. + The argument must have a bit-vector sort. + + + + + Bit-vector repetition. + + + The argument must have a bit-vector sort. + + + + + Shift left. + + + It is equivalent to multiplication by 2^x where \c x is the value of . + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The arguments must have a bit-vector sort. + + + + + Logical shift right + + + It is equivalent to unsigned division by 2^x where \c x is the value of . + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The arguments must have a bit-vector sort. + + + + + Arithmetic shift right + + + It is like logical shift right except that the most significant + bits of the result always copy the most significant bit of the + second argument. + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The arguments must have a bit-vector sort. + + + + + Rotate Left. + + + Rotate bits of \c t to the left \c i times. + The argument must have a bit-vector sort. + + + + + Rotate Right. + + + Rotate bits of \c t to the right \c i times. + The argument must have a bit-vector sort. + + + + + Rotate Left. + + + Rotate bits of to the left times. + The arguments must have the same bit-vector sort. + + + + + Rotate Right. + + + Rotate bits of to the right times. + The arguments must have the same bit-vector sort. + + + + + Create an bit bit-vector from the integer argument . + + + NB. This function is essentially treated as uninterpreted. + So you cannot expect Z3 to precisely reflect the semantics of this function + when solving constraints with this function. + + The argument must be of integer sort. + + + + + Create an integer from the bit-vector argument . + + + If \c is_signed is false, then the bit-vector \c t1 is treated as unsigned. + So the result is non-negative and in the range [0..2^N-1], where + N are the number of bits in . + If \c is_signed is true, \c t1 is treated as a signed bit-vector. + + NB. This function is essentially treated as uninterpreted. + So you cannot expect Z3 to precisely reflect the semantics of this function + when solving constraints with this function. + + The argument must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise addition does not overflow. + + + The arguments must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise addition does not underflow. + + + The arguments must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise subtraction does not overflow. + + + The arguments must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise subtraction does not underflow. + + + The arguments must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise signed division does not overflow. + + + The arguments must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise negation does not overflow. + + + The arguments must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise multiplication does not overflow. + + + The arguments must be of bit-vector sort. + + + + + Create a predicate that checks that the bit-wise multiplication does not underflow. + + + The arguments must be of bit-vector sort. + + + + + Create an array constant. + + + + + Create an array constant. + + + + + Array read. + + + The argument a is the array and i is the index + of the array that gets read. + + The node a must have an array sort [domain -> range], + and i must have the sort domain. + The sort of the result is range. + + + + + + + Array read. + + + The argument a is the array and args are the indices + of the array that gets read. + + The node a must have an array sort [domain1,..,domaink -> range], + and args must have the sort domain1,..,domaink. + The sort of the result is range. + + + + + + + Array update. + + + The node a must have an array sort [domain -> range], + i must have sort domain, + v must have sort range. The sort of the result is [domain -> range]. + The semantics of this function is given by the theory of arrays described in the SMT-LIB + standard. See http://smtlib.org for more details. + The result of this function is an array that is equal to a + (with respect to select) + on all indices except for i, where it maps to v + (and the select of a with + respect to i may be a different value). + + + + + + + + Array update. + + + The node a must have an array sort [domain1,..,domaink -> range], + args must have sort domain1,..,domaink, + v must have sort range. The sort of the result is [domain -> range]. + The semantics of this function is given by the theory of arrays described in the SMT-LIB + standard. See http://smtlib.org for more details. + The result of this function is an array that is equal to a + (with respect to select) + on all indices except for args, where it maps to v + (and the select of a with + respect to args may be a different value). + + + + + + + + Create a constant array. + + + The resulting term is an array, such that a selecton an arbitrary index + produces the value v. + + + + + + + Maps f on the argument arrays. + + + Each element of args must be of an array sort [domain_i -> range_i]. + The function declaration f must have type range_1 .. range_n -> range. + v must have sort range. The sort of the result is [domain_i -> range]. + + + + + + + + Access the array default value. + + + Produces the default range value, for arrays that can be represented as + finite maps with a default range value. + + + + + Create Extentionality index. Two arrays are equal if and only if they are equal on the index returned by MkArrayExt. + + + + + Create a set type. + + + + + Create an empty set. + + + + + Create the full set. + + + + + Add an element to the set. + + + + + Remove an element from a set. + + + + + Take the union of a list of sets. + + + + + Take the intersection of a list of sets. + + + + + Take the difference between two sets. + + + + + Take the complement of a set. + + + + + Check for set membership. + + + + + Check for subsetness of sets. + + + + + Create the empty sequence. + + + + + Create the singleton sequence. + + + + + Create a string constant. + + + + + Convert an integer expression to a string. + + + + + Convert a bit-vector expression, represented as an unsigned number, to a string. + + + + + Convert a bit-vector expression, represented as an signed number, to a string. + + + + + Convert an integer expression to a string. + + + + + Concatenate sequences. + + + + + Retrieve the length of a given sequence. + + + + + Check for sequence prefix. + + + + + Check for sequence suffix. + + + + + Check for sequence containment of s2 in s1. + + + + + Check if the string s1 is lexicographically strictly less than s2. + + + + + Check if the string s1 is lexicographically strictly less than s2. + + + + + Retrieve sequence of length one at index. + + + + + Retrieve element at index. + + + + + Extract subsequence. + + + + + Extract index of sub-string starting at offset. + + + + + Replace the first occurrence of src by dst in s. + + + + + Convert a regular expression that accepts sequence s. + + + + + Check for regular expression membership. + + + + + Take the Kleene star of a regular expression. + + + + + Take the bounded Kleene star of a regular expression. + + + + + Take the Kleene plus of a regular expression. + + + + + Create the optional regular expression. + + + + + Create the complement regular expression. + + + + + Create the concatenation of regular languages. + + + + + Create the union of regular languages. + + + + + Create the intersection of regular languages. + + + + + Create a difference regular expression. + + + + + Create the empty regular expression. + The sort s should be a regular expression. + + + + + Create the full regular expression. + The sort s should be a regular expression. + + + + + Create a range expression. + + + + + Create less than or equal to between two characters. + + + + + Create an integer (code point) from character. + + + + + Create a bit-vector (code point) from character. + + + + + Create a character from a bit-vector (code point). + + + + + Create a check if the character is a digit. + + + + + Create an at-most-k constraint. + + + + + Create an at-least-k constraint. + + + + + Create a pseudo-Boolean less-or-equal constraint. + + + + + Create a pseudo-Boolean greater-or-equal constraint. + + + + + Create a pseudo-Boolean equal constraint. + + + + + Create a Term of a given sort. + + A string representing the Term value in decimal notation. If the given sort is a real, then the Term can be a rational, that is, a string of the form [num]* / [num]*. + The sort of the numeral. In the current implementation, the given sort can be an int, real, or bit-vectors of arbitrary size. + A Term with value and sort + + + + Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer. + It is slightly faster than MakeNumeral since it is not necessary to parse a string. + + Value of the numeral + Sort of the numeral + A Term with value and type + + + + Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer. + It is slightly faster than MakeNumeral since it is not necessary to parse a string. + + Value of the numeral + Sort of the numeral + A Term with value and type + + + + Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer. + It is slightly faster than MakeNumeral since it is not necessary to parse a string. + + Value of the numeral + Sort of the numeral + A Term with value and type + + + + Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer. + It is slightly faster than MakeNumeral since it is not necessary to parse a string. + + Value of the numeral + Sort of the numeral + A Term with value and type + + + + Create a real from a fraction. + + numerator of rational. + denominator of rational. + A Term with value / and sort Real + + + + + Create a real numeral. + + A string representing the Term value in decimal notation. + A Term with value and sort Real + + + + Create a real numeral. + + value of the numeral. + A Term with value and sort Real + + + + Create a real numeral. + + value of the numeral. + A Term with value and sort Real + + + + Create a real numeral. + + value of the numeral. + A Term with value and sort Real + + + + Create a real numeral. + + value of the numeral. + A Term with value and sort Real + + + + Create an integer numeral. + + A string representing the Term value in decimal notation. + + + + Create an integer numeral. + + value of the numeral. + A Term with value and sort Integer + + + + Create an integer numeral. + + value of the numeral. + A Term with value and sort Integer + + + + Create an integer numeral. + + value of the numeral. + A Term with value and sort Integer + + + + Create an integer numeral. + + value of the numeral. + A Term with value and sort Integer + + + + Create a bit-vector numeral. + + A string representing the value in decimal notation. + the size of the bit-vector + + + + Create a bit-vector numeral. + + value of the numeral. + the size of the bit-vector + + + + Create a bit-vector numeral. + + value of the numeral. + the size of the bit-vector + + + + Create a bit-vector numeral. + + value of the numeral. + the size of the bit-vector + + + + Create a bit-vector numeral. + + value of the numeral. + the size of the bit-vector + + + + Create a bit-vector numeral. + + An array of bits representing the bit-vector. Least significant bit is at position 0. + + + + Create a universal Quantifier. + + + Creates a forall formula, where is the weight, + is an array of patterns, is an array + with the sorts of the bound variables, is an array with the + 'names' of the bound variables, and is the body of the + quantifier. Quantifiers are associated with weights indicating the importance of + using the quantifier during instantiation. + Note that the bound variables are de-Bruijn indices created using . + Z3 applies the convention that the last element in and + refers to the variable with index 0, the second to last element + of and refers to the variable + with index 1, etc. + + the sorts of the bound variables. + names of the bound variables + the body of the quantifier. + quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + array containing the patterns created using MkPattern. + array containing the anti-patterns created using MkPattern. + optional symbol to track quantifier. + optional symbol to track skolem constants. + + + + Create a universal Quantifier. + + + Creates a universal quantifier using a list of constants that will + form the set of bound variables. + + + + + + Create an existential Quantifier. + + + Creates an existential quantifier using de-Bruijn indexed variables. + (). + + + + + Create an existential Quantifier. + + + Creates an existential quantifier using a list of constants that will + form the set of bound variables. + + + + + + Create a Quantifier. + + + + + + Create a Quantifier. + + + + + + Create a lambda expression. + + + Creates a lambda expression. + is an array + with the sorts of the bound variables, is an array with the + 'names' of the bound variables, and is the body of the + lambda. + Note that the bound variables are de-Bruijn indices created using . + Z3 applies the convention that the last element in and + refers to the variable with index 0, the second to last element + of and refers to the variable + with index 1, etc. + + the sorts of the bound variables. + names of the bound variables + the body of the quantifier. + + + + Create a lambda expression. + + + Creates a lambda expression using a list of constants that will + form the set of bound variables. + + + + + + Selects the format used for pretty-printing expressions. + + + The default mode for pretty printing expressions is to produce + SMT-LIB style output where common subexpressions are printed + at each occurrence. The mode is called Z3_PRINT_SMTLIB_FULL. + To print shared common subexpressions only once, + use the Z3_PRINT_LOW_LEVEL mode. + To print in way that conforms to SMT-LIB standards and uses let + expressions to share common sub-expressions use Z3_PRINT_SMTLIB_COMPLIANT. + + + + + + + + + Parse the given string using the SMT-LIB2 parser. + + A conjunction of assertions in the scope (up to push/pop) at the end of the string. + + + + Parse the given file using the SMT-LIB2 parser. + + + + + + Creates a new Goal. + + + Note that the Context must have been created with proof generation support if + is set to true here. + + Indicates whether model generation should be enabled. + Indicates whether unsat core generation should be enabled. + Indicates whether proof generation should be enabled. + + + + Creates a new ParameterSet. + + + + + The number of supported tactics. + + + + + The names of all supported tactics. + + + + + Returns a string containing a description of the tactic with the given name. + + + + + Creates a new Tactic. + + + + + Create a tactic that applies to a Goal and + then to every subgoal produced by . + + + + + Create a tactic that applies to a Goal and + then to every subgoal produced by . + + + Shorthand for AndThen. + + + + + Create a tactic that first applies to a Goal and + if it fails then returns the result of applied to the Goal. + + + + + Create a tactic that applies to a goal for milliseconds. + + + If does not terminate within milliseconds, then it fails. + + + + + Create a tactic that applies to a given goal if the probe + evaluates to true. + + + If evaluates to false, then the new tactic behaves like the skip tactic. + + + + + Create a tactic that applies to a given goal if the probe + evaluates to true and otherwise. + + + + + Create a tactic that keeps applying until the goal is not + modified anymore or the maximum number of iterations is reached. + + + + + Create a tactic that just returns the given goal. + + + + + Create a tactic always fails. + + + + + Create a tactic that fails if the probe evaluates to false. + + + + + Create a tactic that fails if the goal is not trivially satisfiable (i.e., empty) + or trivially unsatisfiable (i.e., contains `false'). + + + + + Create a tactic that applies using the given set of parameters . + + + + + Create a tactic that applies using the given set of parameters . + + Alias for UsingParams + + + + Create a tactic that applies the given tactics in parallel until one of them succeeds (i.e., the first that doesn't fail). + + + + + Create a tactic that applies to a given goal and then + to every subgoal produced by . The subgoals are processed in parallel. + + + + + Interrupt the execution of a Z3 procedure. + + This procedure can be used to interrupt: solvers, simplifiers and tactics. + + + + The number of supported Probes. + + + + + The names of all supported Probes. + + + + + Returns a string containing a description of the probe with the given name. + + + + + Creates a new Probe. + + + + + Create a probe that always evaluates to . + + + + + Create a probe that evaluates to "true" when the value returned by + is less than the value returned by + + + + + Create a probe that evaluates to "true" when the value returned by + is greater than the value returned by + + + + + Create a probe that evaluates to "true" when the value returned by + is less than or equal the value returned by + + + + + Create a probe that evaluates to "true" when the value returned by + is greater than or equal the value returned by + + + + + Create a probe that evaluates to "true" when the value returned by + is equal to the value returned by + + + + + Create a probe that evaluates to "true" when the value + and evaluate to "true". + + + + + Create a probe that evaluates to "true" when the value + or evaluate to "true". + + + + + Create a probe that evaluates to "true" when the value + does not evaluate to "true". + + + + + Creates a new (incremental) solver. + + + This solver also uses a set of builtin tactics for handling the first + check-sat command, and check-sat commands that take more than a given + number of milliseconds to be solved. + + + + + Creates a new (incremental) solver. + + + + + + Creates a new (incremental) solver. + + + + + Creates a solver that is implemented using the given tactic. + + + The solver supports the commands Push and Pop, but it + will always solve each check from scratch. + + + + + Create a Fixedpoint context. + + + + + Create an Optimization context. + + + + + Create the floating-point RoundingMode sort. + + + + + Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the RoundTowardPositive rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the RoundTowardPositive rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the RoundTowardNegative rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the RoundTowardNegative rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the RoundTowardZero rounding mode. + + + + + Create a numeral of RoundingMode sort which represents the RoundTowardZero rounding mode. + + + + + Create a FloatingPoint sort. + + exponent bits in the FloatingPoint sort. + significand bits in the FloatingPoint sort. + + + + Create the half-precision (16-bit) FloatingPoint sort. + + + + + Create the half-precision (16-bit) FloatingPoint sort. + + + + + Create the single-precision (32-bit) FloatingPoint sort. + + + + + Create the single-precision (32-bit) FloatingPoint sort. + + + + + Create the double-precision (64-bit) FloatingPoint sort. + + + + + Create the double-precision (64-bit) FloatingPoint sort. + + + + + Create the quadruple-precision (128-bit) FloatingPoint sort. + + + + + Create the quadruple-precision (128-bit) FloatingPoint sort. + + + + + Create a NaN of sort s. + + FloatingPoint sort. + + + + Create a floating-point infinity of sort s. + + FloatingPoint sort. + indicates whether the result should be negative. + + + + Create a floating-point zero of sort s. + + FloatingPoint sort. + indicates whether the result should be negative. + + + + Create a numeral of FloatingPoint sort from a float. + + numeral value. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from a float. + + numeral value. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from an int. + + numeral value. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from a sign bit and two integers. + + the sign. + the significand. + the exponent. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers. + + the sign. + the significand. + the exponent. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from a float. + + numeral value. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from a float. + + numeral value. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from an int. + + numeral value. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from a sign bit and two integers. + + the sign. + the exponent. + the significand. + FloatingPoint sort. + + + + Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers. + + the sign. + the exponent. + the significand. + FloatingPoint sort. + + + + Floating-point absolute value + + floating-point term + + + + Floating-point negation + + floating-point term + + + + Floating-point addition + + rounding mode term + floating-point term + floating-point term + + + + Floating-point subtraction + + rounding mode term + floating-point term + floating-point term + + + + Floating-point multiplication + + rounding mode term + floating-point term + floating-point term + + + + Floating-point division + + rounding mode term + floating-point term + floating-point term + + + + Floating-point fused multiply-add + + + The result is round((t1 * t2) + t3) + + rounding mode term + floating-point term + floating-point term + floating-point term + + + + Floating-point square root + + rounding mode term + floating-point term + + + + Floating-point remainder + + floating-point term + floating-point term + + + + Floating-point roundToIntegral. Rounds a floating-point number to + the closest integer, again represented as a floating-point number. + + term of RoundingMode sort + floating-point term + + + + Minimum of floating-point numbers. + + floating-point term + floating-point term + + + + Maximum of floating-point numbers. + + floating-point term + floating-point term + + + + Floating-point less than or equal. + + floating-point term + floating-point term + + + + Floating-point less than. + + floating-point term + floating-point term + + + + Floating-point greater than or equal. + + floating-point term + floating-point term + + + + Floating-point greater than. + + floating-point term + floating-point term + + + + Floating-point equality. + + + Note that this is IEEE 754 equality (as opposed to standard =). + + floating-point term + floating-point term + + + + Predicate indicating whether t is a normal floating-point number. + + floating-point term + + + + Predicate indicating whether t is a subnormal floating-point number. + + floating-point term + + + + Predicate indicating whether t is a floating-point number with zero value, i.e., +0 or -0. + + floating-point term + + + + Predicate indicating whether t is a floating-point number representing +oo or -oo. + + floating-point term + + + + Predicate indicating whether t is a NaN. + + floating-point term + + + + Predicate indicating whether t is a negative floating-point number. + + floating-point term + + + + Predicate indicating whether t is a positive floating-point number. + + floating-point term + + + + Create an expression of FloatingPoint sort from three bit-vector expressions. + + + This is the operator named `fp' in the SMT FP theory definition. + Note that sgn is required to be a bit-vector of size 1. Significand and exponent + are required to be greater than 1 and 2 respectively. The FloatingPoint sort + of the resulting expression is automatically determined from the bit-vector sizes + of the arguments. + + bit-vector term (of size 1) representing the sign. + bit-vector term representing the significand. + bit-vector term representing the exponent. + + + + Conversion of a single IEEE 754-2008 bit-vector into a floating-point number. + + + Produces a term that represents the conversion of a bit-vector term bv to a + floating-point term of sort s. The bit-vector size of bv (m) must be equal + to ebits+sbits of s. The format of the bit-vector is as defined by the + IEEE 754-2008 interchange format. + + bit-vector value (of size m). + FloatingPoint sort (ebits+sbits == m) + + + + Conversion of a FloatingPoint term into another term of different FloatingPoint sort. + + + Produces a term that represents the conversion of a floating-point term t to a + floating-point term of sort s. If necessary, the result will be rounded according + to rounding mode rm. + + RoundingMode term. + FloatingPoint term. + FloatingPoint sort. + + + + Conversion of a term of real sort into a term of FloatingPoint sort. + + + Produces a term that represents the conversion of term t of real sort into a + floating-point term of sort s. If necessary, the result will be rounded according + to rounding mode rm. + + RoundingMode term. + term of Real sort. + FloatingPoint sort. + + + + Conversion of a 2's complement signed bit-vector term into a term of FloatingPoint sort. + + + Produces a term that represents the conversion of the bit-vector term t into a + floating-point term of sort s. The bit-vector t is taken to be in signed + 2's complement format (when signed==true, otherwise unsigned). If necessary, the + result will be rounded according to rounding mode rm. + + RoundingMode term. + term of bit-vector sort. + FloatingPoint sort. + flag indicating whether t is interpreted as signed or unsigned bit-vector. + + + + Conversion of a floating-point number to another FloatingPoint sort s. + + + Produces a term that represents the conversion of a floating-point term t to a different + FloatingPoint sort s. If necessary, rounding according to rm is applied. + + FloatingPoint sort + floating-point rounding mode term + floating-point term + + + + Conversion of a floating-point term into a bit-vector. + + + Produces a term that represents the conversion of the floating-point term t into a + bit-vector term of size sz in 2's complement format (signed when signed==true). If necessary, + the result will be rounded according to rounding mode rm. + + RoundingMode term. + FloatingPoint term + Size of the resulting bit-vector. + Indicates whether the result is a signed or unsigned bit-vector. + + + + Conversion of a floating-point term into a real-numbered term. + + + Produces a term that represents the conversion of the floating-point term t into a + real number. Note that this type of conversion will often result in non-linear + constraints over real terms. + + FloatingPoint term + + + + Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format. + + + The size of the resulting bit-vector is automatically determined. Note that + IEEE 754-2008 allows multiple different representations of NaN. This conversion + knows only one NaN and it will always produce the same bit-vector representation of + that NaN. + + FloatingPoint term. + + + + Conversion of a real-sorted significand and an integer-sorted exponent into a term of FloatingPoint sort. + + + Produces a term that represents the conversion of sig * 2^exp into a + floating-point term of sort s. If necessary, the result will be rounded + according to rounding mode rm. + + RoundingMode term. + Exponent term of Int sort. + Significand term of Real sort. + FloatingPoint sort. + + + + Wraps an AST. + + This function is used for transitions between native and + managed objects. Note that must be a + native object obtained from Z3 (e.g., through ) + and that it must have a correct reference count (see e.g., + . + + The native pointer to wrap. + + + + Unwraps an AST. + + This function is used for transitions between native and + managed objects. It returns the native pointer to the AST. Note that + AST objects are reference counted and unwrapping an AST disables automatic + reference counting, i.e., all references to the IntPtr that is returned + must be handled externally and through native calls (see e.g., + ). + + The AST to unwrap. + + + + Return a string describing all available parameters to Expr.Simplify. + + + + + Retrieves parameter descriptions for simplifier. + + + + + Update a mutable configuration parameter. + + + The list of all configuration parameters can be obtained using the Z3 executable: + z3.exe -p + Only a few configuration parameters are mutable once the context is created. + An exception is thrown when trying to modify an immutable parameter. + + + + + AST DRQ + + + + + ASTMap DRQ + + + + + ASTVector DRQ + + + + + ApplyResult DRQ + + + + + FuncEntry DRQ + + + + + FuncInterp DRQ + + + + + Goal DRQ + + + + + Model DRQ + + + + + Params DRQ + + + + + ParamDescrs DRQ + + + + + Probe DRQ + + + + + Solver DRQ + + + + + Statistics DRQ + + + + + Tactic DRQ + + + + + FixedPoint DRQ + + + + + Optimize DRQ + + + + + Finalizer. + + + + + Disposes of the context. + + + + + Datatype expressions + + + + Constructor for DatatypeExpr + + + + Datatype sorts. + + + + + The number of constructors of the datatype sort. + + + + + The constructors. + + + + + The recognizers. + + + + + The constructor accessors. + + + + + The main interaction with Z3 happens via the Context. + + + + + Enumeration sorts. + + + + + The function declarations of the constants in the enumeration. + + + + + Retrieves the inx'th constant declaration in the enumeration. + + + + + + + The constants in the enumeration. + + + + + Retrieves the inx'th constant in the enumeration. + + + + + + + The test predicates (recognizers) for the constants in the enumeration. + + + + + Retrieves the inx'th tester/recognizer declaration in the enumeration. + + + + + + + Expressions are terms. + + + + + Returns a simplified version of the expression. + + A set of parameters to configure the simplifier + + + + + The function declaration of the function that is applied in this expression. + + + + + Indicates whether the expression is the true or false expression + or something else (Z3_L_UNDEF). + + + + + The number of arguments of the expression. + + + + + The arguments of the expression. + + + + + The i'th argument of the expression. + + + + + Update the arguments of the expression using the arguments + The number of new arguments should coincide with the current number of arguments. + + + + + Substitute every occurrence of from[i] in the expression with to[i], for i smaller than num_exprs. + + + The result is the new expression. The arrays from and to must have size num_exprs. + For every i smaller than num_exprs, we must have that + sort of from[i] must be equal to sort of to[i]. + + + + + Substitute every occurrence of from in the expression with to. + + + + + + Substitute the free variables in the expression with the expressions in + + + For every i smaller than num_exprs, the variable with de-Bruijn index i is replaced with term to[i]. + + + + + Translates (copies) the term to the Context . + + A context + A copy of the term which is associated with + + + + Returns a string representation of the expression. + + + + + Indicates whether the term is a numeral + + + + + Indicates whether the term is well-sorted. + + True if the term is well-sorted, false otherwise. + + + + The Sort of the term. + + + + + Indicates whether the term represents a constant. + + + + + Indicates whether the term is an integer numeral. + + + + + Indicates whether the term is a real numeral. + + + + + Indicates whether the term is an algebraic number + + + + + Indicates whether the term has Boolean sort. + + + + + Indicates whether the term is the constant true. + + + + + Indicates whether the term is the constant false. + + + + + Indicates whether the term is an equality predicate. + + + + + Indicates whether the term is an n-ary distinct predicate (every argument is mutually distinct). + + + + + Indicates whether the term is a ternary if-then-else term + + + + + Indicates whether the term is an n-ary conjunction + + + + + Indicates whether the term is an n-ary disjunction + + + + + Indicates whether the term is an if-and-only-if (Boolean equivalence, binary) + + + + + Indicates whether the term is an exclusive or + + + + + Indicates whether the term is a negation + + + + + Indicates whether the term is an implication + + + + + Indicates whether the term is at-most + + + + + Retrieve bound of at-most + + + + + Indicates whether the term is at-least + + + + + Retrieve bound of at-least + + + + + Indicates whether the term is pbeq + + + + + Indicates whether the term is pble + + + + + Indicates whether the term is pbge + + + + + Indicates whether the term is of integer sort. + + + + + Indicates whether the term is of sort real. + + + + + Indicates whether the term is an arithmetic numeral. + + + + + Indicates whether the term is a less-than-or-equal + + + + + Indicates whether the term is a greater-than-or-equal + + + + + Indicates whether the term is a less-than + + + + + Indicates whether the term is a greater-than + + + + + Indicates whether the term is addition (binary) + + + + + Indicates whether the term is subtraction (binary) + + + + + Indicates whether the term is a unary minus + + + + + Indicates whether the term is multiplication (binary) + + + + + Indicates whether the term is division (binary) + + + + + Indicates whether the term is integer division (binary) + + + + + Indicates whether the term is remainder (binary) + + + + + Indicates whether the term is modulus (binary) + + + + + Indicates whether the term is a coercion of integer to real (unary) + + + + + Indicates whether the term is a coercion of real to integer (unary) + + + + + Indicates whether the term is a check that tests whether a real is integral (unary) + + + + + Indicates whether the term is of an array sort. + + + + + Indicates whether the term is an array store. + + It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j). + Array store takes at least 3 arguments. + + + + Indicates whether the term is an array select. + + + + + Indicates whether the term is a constant array. + + For example, select(const(v),i) = v holds for every v and i. The function is unary. + + + + Indicates whether the term is a default array. + + For example default(const(v)) = v. The function is unary. + + + + Indicates whether the term is an array map. + + It satisfies map[f](a1,..,a_n)[i] = f(a1[i],...,a_n[i]) for every i. + + + + Indicates whether the term is an as-array term. + + An as-array term is n array value that behaves as the function graph of the + function passed as parameter. + + + + Indicates whether the term is set union + + + + + Indicates whether the term is set intersection + + + + + Indicates whether the term is set difference + + + + + Indicates whether the term is set complement + + + + + Indicates whether the term is set subset + + + + + Indicates whether the terms is of bit-vector sort. + + + + + Indicates whether the term is a bit-vector numeral + + + + + Indicates whether the term is a one-bit bit-vector with value one + + + + + Indicates whether the term is a one-bit bit-vector with value zero + + + + + Indicates whether the term is a bit-vector unary minus + + + + + Indicates whether the term is a bit-vector addition (binary) + + + + + Indicates whether the term is a bit-vector subtraction (binary) + + + + + Indicates whether the term is a bit-vector multiplication (binary) + + + + + Indicates whether the term is a bit-vector signed division (binary) + + + + + Indicates whether the term is a bit-vector unsigned division (binary) + + + + + Indicates whether the term is a bit-vector signed remainder (binary) + + + + + Indicates whether the term is a bit-vector unsigned remainder (binary) + + + + + Indicates whether the term is a bit-vector signed modulus + + + + + Indicates whether the term is a bit-vector signed division by zero + + + + + Indicates whether the term is a bit-vector unsigned division by zero + + + + + Indicates whether the term is a bit-vector signed remainder by zero + + + + + Indicates whether the term is a bit-vector unsigned remainder by zero + + + + + Indicates whether the term is a bit-vector signed modulus by zero + + + + + Indicates whether the term is an unsigned bit-vector less-than-or-equal + + + + + Indicates whether the term is a signed bit-vector less-than-or-equal + + + + + Indicates whether the term is an unsigned bit-vector greater-than-or-equal + + + + + Indicates whether the term is a signed bit-vector greater-than-or-equal + + + + + Indicates whether the term is an unsigned bit-vector less-than + + + + + Indicates whether the term is a signed bit-vector less-than + + + + + Indicates whether the term is an unsigned bit-vector greater-than + + + + + Indicates whether the term is a signed bit-vector greater-than + + + + + Indicates whether the term is a bit-wise AND + + + + + Indicates whether the term is a bit-wise OR + + + + + Indicates whether the term is a bit-wise NOT + + + + + Indicates whether the term is a bit-wise XOR + + + + + Indicates whether the term is a bit-wise NAND + + + + + Indicates whether the term is a bit-wise NOR + + + + + Indicates whether the term is a bit-wise XNOR + + + + + Indicates whether the term is a bit-vector concatenation (binary) + + + + + Indicates whether the term is a bit-vector sign extension + + + + + Indicates whether the term is a bit-vector zero extension + + + + + Indicates whether the term is a bit-vector extraction + + + + + Indicates whether the term is a bit-vector repetition + + + + + Indicates whether the term is a bit-vector reduce OR + + + + + Indicates whether the term is a bit-vector reduce AND + + + + + Indicates whether the term is a bit-vector comparison + + + + + Indicates whether the term is a bit-vector shift left + + + + + Indicates whether the term is a bit-vector logical shift right + + + + + Indicates whether the term is a bit-vector arithmetic shift left + + + + + Indicates whether the term is a bit-vector rotate left + + + + + Indicates whether the term is a bit-vector rotate right + + + + + Indicates whether the term is a bit-vector rotate left (extended) + + Similar to Z3_OP_ROTATE_LEFT, but it is a binary operator instead of a parametric one. + + + + Indicates whether the term is a bit-vector rotate right (extended) + + Similar to Z3_OP_ROTATE_RIGHT, but it is a binary operator instead of a parametric one. + + + + Indicates whether the term is a coercion from integer to bit-vector + + This function is not supported by the decision procedures. Only the most + rudimentary simplification rules are applied to this function. + + + + Indicates whether the term is a coercion from bit-vector to integer + + This function is not supported by the decision procedures. Only the most + rudimentary simplification rules are applied to this function. + + + + Indicates whether the term is a bit-vector carry + + Compute the carry bit in a full-adder. The meaning is given by the + equivalence (carry l1 l2 l3) <=> (or (and l1 l2) (and l1 l3) (and l2 l3))) + + + + Indicates whether the term is a bit-vector ternary XOR + + The meaning is given by the equivalence (xor3 l1 l2 l3) <=> (xor (xor l1 l2) l3) + + + + Indicates whether the term is a label (used by the Boogie Verification condition generator). + + The label has two parameters, a string and a Boolean polarity. It takes one argument, a formula. + + + + Indicates whether the term is a label literal (used by the Boogie Verification condition generator). + + A label literal has a set of string parameters. It takes no arguments. + + + + Check whether expression is a string constant. + + a Boolean + + + + Retrieve string corresponding to string constant. + + the expression should be a string constant, (IsString should be true). + + + + Check whether expression is a concatenation. + + a Boolean + + + + Check whether expression is a prefix. + + a Boolean + + + + Check whether expression is a suffix. + + a Boolean + + + + Check whether expression is a contains. + + a Boolean + + + + Check whether expression is an extract. + + a Boolean + + + + Check whether expression is a replace. + + a Boolean + + + + Check whether expression is an at. + + a Boolean + + + + Check whether expression is a sequence length. + + a Boolean + + + + Check whether expression is a sequence index. + + a Boolean + + + + Indicates whether the term is a binary equivalence modulo namings. + + This binary predicate is used in proof terms. + It captures equisatisfiability and equivalence modulo renamings. + + + + Indicates whether the term is a Proof for the expression 'true'. + + + + + Indicates whether the term is a proof for a fact asserted by the user. + + + + + Indicates whether the term is a proof for a fact (tagged as goal) asserted by the user. + + + + + Indicates whether the term is proof via modus ponens + + + Given a proof for p and a proof for (implies p q), produces a proof for q. + T1: p + T2: (implies p q) + [mp T1 T2]: q + The second antecedents may also be a proof for (iff p q). + + + + Indicates whether the term is a proof for (R t t), where R is a reflexive relation. + + This proof object has no antecedents. + The only reflexive relations that are used are + equivalence modulo namings, equality and equivalence. + That is, R is either '~', '=' or 'iff'. + + + + Indicates whether the term is proof by symmetricity of a relation + + + Given an symmetric relation R and a proof for (R t s), produces a proof for (R s t). + T1: (R t s) + [symmetry T1]: (R s t) + T1 is the antecedent of this proof object. + + + + + Indicates whether the term is a proof by transitivity of a relation + + + Given a transitive relation R, and proofs for (R t s) and (R s u), produces a proof + for (R t u). + T1: (R t s) + T2: (R s u) + [trans T1 T2]: (R t u) + + + + + Indicates whether the term is a proof by condensed transitivity of a relation + + + Condensed transitivity proof. + It combines several symmetry and transitivity proofs. + Example: + T1: (R a b) + T2: (R c b) + T3: (R c d) + [trans* T1 T2 T3]: (R a d) + R must be a symmetric and transitive relation. + + Assuming that this proof object is a proof for (R s t), then + a proof checker must check if it is possible to prove (R s t) + using the antecedents, symmetry and transitivity. That is, + if there is a path from s to t, if we view every + antecedent (R a b) as an edge between a and b. + + + + + Indicates whether the term is a monotonicity proof object. + + + T1: (R t_1 s_1) + ... + Tn: (R t_n s_n) + [monotonicity T1 ... Tn]: (R (f t_1 ... t_n) (f s_1 ... s_n)) + Remark: if t_i == s_i, then the antecedent Ti is suppressed. + That is, reflexivity proofs are suppressed to save space. + + + + + Indicates whether the term is a quant-intro proof + + + Given a proof for (~ p q), produces a proof for (~ (forall (x) p) (forall (x) q)). + T1: (~ p q) + [quant-intro T1]: (~ (forall (x) p) (forall (x) q)) + + + + + Indicates whether the term is a distributivity proof object. + + + Given that f (= or) distributes over g (= and), produces a proof for + (= (f a (g c d)) + (g (f a c) (f a d))) + If f and g are associative, this proof also justifies the following equality: + (= (f (g a b) (g c d)) + (g (f a c) (f a d) (f b c) (f b d))) + where each f and g can have arbitrary number of arguments. + + This proof object has no antecedents. + Remark. This rule is used by the CNF conversion pass and + instantiated by f = or, and g = and. + + + + + Indicates whether the term is a proof by elimination of AND + + + Given a proof for (and l_1 ... l_n), produces a proof for l_i + T1: (and l_1 ... l_n) + [and-elim T1]: l_i + + + + + Indicates whether the term is a proof by elimination of not-or + + + Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i). + T1: (not (or l_1 ... l_n)) + [not-or-elim T1]: (not l_i) + + + + + Indicates whether the term is a proof by rewriting + + + A proof for a local rewriting step (= t s). + The head function symbol of t is interpreted. + + This proof object has no antecedents. + The conclusion of a rewrite rule is either an equality (= t s), + an equivalence (iff t s), or equi-satisfiability (~ t s). + Remark: if f is bool, then = is iff. + + Examples: + (= (+ x 0) x) + (= (+ x 1 2) (+ 3 x)) + (iff (or x false) x) + + + + + Indicates whether the term is a proof by rewriting + + + A proof for rewriting an expression t into an expression s. + This proof object can have n antecedents. + The antecedents are proofs for equalities used as substitution rules. + The object is used in a few cases: + - When applying contextual simplification (CONTEXT_SIMPLIFIER=true) + - When converting bit-vectors to Booleans (BIT2BOOL=true) + + + + + Indicates whether the term is a proof for pulling quantifiers out. + + + A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents. + + + + + Indicates whether the term is a proof for pushing quantifiers in. + + + A proof for: + (iff (forall (x_1 ... x_m) (and p_1[x_1 ... x_m] ... p_n[x_1 ... x_m])) + (and (forall (x_1 ... x_m) p_1[x_1 ... x_m]) + ... + (forall (x_1 ... x_m) p_n[x_1 ... x_m]))) + This proof object has no antecedents + + + + + Indicates whether the term is a proof for elimination of unused variables. + + + A proof for (iff (forall (x_1 ... x_n y_1 ... y_m) p[x_1 ... x_n]) + (forall (x_1 ... x_n) p[x_1 ... x_n])) + + It is used to justify the elimination of unused variables. + This proof object has no antecedents. + + + + + Indicates whether the term is a proof for destructive equality resolution + + + A proof for destructive equality resolution: + (iff (forall (x) (or (not (= x t)) P[x])) P[t]) + if x does not occur in t. + + This proof object has no antecedents. + + Several variables can be eliminated simultaneously. + + + + + Indicates whether the term is a proof for quantifier instantiation + + + A proof of (or (not (forall (x) (P x))) (P a)) + + + + + Indicates whether the term is a hypothesis marker. + + Mark a hypothesis in a natural deduction style proof. + + + + Indicates whether the term is a proof by lemma + + + T1: false + [lemma T1]: (or (not l_1) ... (not l_n)) + + This proof object has one antecedent: a hypothetical proof for false. + It converts the proof in a proof for (or (not l_1) ... (not l_n)), + when T1 contains the hypotheses: l_1, ..., l_n. + + + + + Indicates whether the term is a proof by unit resolution + + + T1: (or l_1 ... l_n l_1' ... l_m') + T2: (not l_1) + ... + T(n+1): (not l_n) + [unit-resolution T1 ... T(n+1)]: (or l_1' ... l_m') + + + + + Indicates whether the term is a proof by iff-true + + + T1: p + [iff-true T1]: (iff p true) + + + + + Indicates whether the term is a proof by iff-false + + + T1: (not p) + [iff-false T1]: (iff p false) + + + + + Indicates whether the term is a proof by commutativity + + + [comm]: (= (f a b) (f b a)) + + f is a commutative operator. + + This proof object has no antecedents. + Remark: if f is bool, then = is iff. + + + + + Indicates whether the term is a proof for Tseitin-like axioms + + + Proof object used to justify Tseitin's like axioms: + + (or (not (and p q)) p) + (or (not (and p q)) q) + (or (not (and p q r)) p) + (or (not (and p q r)) q) + (or (not (and p q r)) r) + ... + (or (and p q) (not p) (not q)) + (or (not (or p q)) p q) + (or (or p q) (not p)) + (or (or p q) (not q)) + (or (not (iff p q)) (not p) q) + (or (not (iff p q)) p (not q)) + (or (iff p q) (not p) (not q)) + (or (iff p q) p q) + (or (not (ite a b c)) (not a) b) + (or (not (ite a b c)) a c) + (or (ite a b c) (not a) (not b)) + (or (ite a b c) a (not c)) + (or (not (not a)) (not a)) + (or (not a) a) + + This proof object has no antecedents. + Note: all axioms are propositional tautologies. + Note also that 'and' and 'or' can take multiple arguments. + You can recover the propositional tautologies by + unfolding the Boolean connectives in the axioms a small + bounded number of steps (=3). + + + + + Indicates whether the term is a proof for introduction of a name + + + Introduces a name for a formula/term. + Suppose e is an expression with free variables x, and def-intro + introduces the name n(x). The possible cases are: + + When e is of Boolean type: + [def-intro]: (and (or n (not e)) (or (not n) e)) + + or: + [def-intro]: (or (not n) e) + when e only occurs positively. + + When e is of the form (ite cond th el): + [def-intro]: (and (or (not cond) (= n th)) (or cond (= n el))) + + Otherwise: + [def-intro]: (= n e) + + + + + Indicates whether the term is a proof for application of a definition + + + [apply-def T1]: F ~ n + F is 'equivalent' to n, given that T1 is a proof that + n is a name for F. + + + + + Indicates whether the term is a proof iff-oeq + + + T1: (iff p q) + [iff~ T1]: (~ p q) + + + + + Indicates whether the term is a proof for a positive NNF step + + + Proof for a (positive) NNF step. Example: + + T1: (not s_1) ~ r_1 + T2: (not s_2) ~ r_2 + T3: s_1 ~ r_1' + T4: s_2 ~ r_2' + [nnf-pos T1 T2 T3 T4]: (~ (iff s_1 s_2) + (and (or r_1 r_2') (or r_1' r_2))) + + The negation normal form steps NNF_POS and NNF_NEG are used in the following cases: + (a) When creating the NNF of a positive force quantifier. + The quantifier is retained (unless the bound variables are eliminated). + Example + T1: q ~ q_new + [nnf-pos T1]: (~ (forall (x T) q) (forall (x T) q_new)) + + (b) When recursively creating NNF over Boolean formulas, where the top-level + connective is changed during NNF conversion. The relevant Boolean connectives + for NNF_POS are 'implies', 'iff', 'xor', 'ite'. + NNF_NEG furthermore handles the case where negation is pushed + over Boolean connectives 'and' and 'or'. + + + + + Indicates whether the term is a proof for a negative NNF step + + + Proof for a (negative) NNF step. Examples: + + T1: (not s_1) ~ r_1 + ... + Tn: (not s_n) ~ r_n + [nnf-neg T1 ... Tn]: (not (and s_1 ... s_n)) ~ (or r_1 ... r_n) + and + T1: (not s_1) ~ r_1 + ... + Tn: (not s_n) ~ r_n + [nnf-neg T1 ... Tn]: (not (or s_1 ... s_n)) ~ (and r_1 ... r_n) + and + T1: (not s_1) ~ r_1 + T2: (not s_2) ~ r_2 + T3: s_1 ~ r_1' + T4: s_2 ~ r_2' + [nnf-neg T1 T2 T3 T4]: (~ (not (iff s_1 s_2)) + (and (or r_1 r_2) (or r_1' r_2'))) + + + + + Indicates whether the term is a proof for a Skolemization step + + + Proof for: + + [sk]: (~ (not (forall x (p x y))) (not (p (sk y) y))) + [sk]: (~ (exists x (p x y)) (p (sk y) y)) + + This proof object has no antecedents. + + + + + Indicates whether the term is a proof by modus ponens for equi-satisfiability. + + + Modus ponens style rule for equi-satisfiability. + T1: p + T2: (~ p q) + [mp~ T1 T2]: q + + + + + Indicates whether the term is a proof for theory lemma + + + Generic proof for theory lemmas. + + The theory lemma function comes with one or more parameters. + The first parameter indicates the name of the theory. + For the theory of arithmetic, additional parameters provide hints for + checking the theory lemma. + The hints for arithmetic are: + - farkas - followed by rational coefficients. Multiply the coefficients to the + inequalities in the lemma, add the (negated) inequalities and obtain a contradiction. + - triangle-eq - Indicates a lemma related to the equivalence: + (iff (= t1 t2) (and (<= t1 t2) (<= t2 t1))) + - gcd-test - Indicates an integer linear arithmetic lemma that uses a gcd test. + + + + + Indicates whether the term is of relation sort. + + + + + Indicates whether the term is an relation store + + + Insert a record into a relation. + The function takes n+1 arguments, where the first argument is the relation and the remaining n elements + correspond to the n columns of the relation. + + + + + Indicates whether the term is an empty relation + + + + + Indicates whether the term is a test for the emptiness of a relation + + + + + Indicates whether the term is a relational join + + + + + Indicates whether the term is the union or convex hull of two relations. + + The function takes two arguments. + + + + Indicates whether the term is the widening of two relations + + The function takes two arguments. + + + + Indicates whether the term is a projection of columns (provided as numbers in the parameters). + + The function takes one argument. + + + + Indicates whether the term is a relation filter + + + Filter (restrict) a relation with respect to a predicate. + The first argument is a relation. + The second argument is a predicate with free de-Bruijn indices + corresponding to the columns of the relation. + So the first column in the relation has index 0. + + + + + Indicates whether the term is an intersection of a relation with the negation of another. + + + Intersect the first relation with respect to negation + of the second relation (the function takes two arguments). + Logically, the specification can be described by a function + + target = filter_by_negation(pos, neg, columns) + + where columns are pairs c1, d1, .., cN, dN of columns from pos and neg, such that + target are elements in x in pos, such that there is no y in neg that agrees with + x on the columns c1, d1, .., cN, dN. + + + + + Indicates whether the term is the renaming of a column in a relation + + + The function takes one argument. + The parameters contain the renaming as a cycle. + + + + + Indicates whether the term is the complement of a relation + + + + + Indicates whether the term is a relational select + + + Check if a record is an element of the relation. + The function takes n+1 arguments, where the first argument is a relation, + and the remaining n arguments correspond to a record. + + + + + Indicates whether the term is a relational clone (copy) + + + Create a fresh copy (clone) of a relation. + The function is logically the identity, but + in the context of a register machine allows + for terms of kind + to perform destructive updates to the first argument. + + + + + Indicates whether the term is of an array sort. + + + + + Indicates whether the term is a less than predicate over a finite domain. + + + + + Indicates whether the terms is of floating-point sort. + + + + + Indicates whether the terms is of floating-point rounding mode sort. + + + + + Indicates whether the term is a floating-point numeral + + + + + Indicates whether the term is a floating-point rounding mode numeral + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToEven + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToAway + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardNegative + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardPositive + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardZero + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToEven + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToAway + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardNegative + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardPositive + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardZero + + + + + Indicates whether the term is a floating-point rounding mode numeral + + + + + Indicates whether the term is a floating-point +oo + + + + + Indicates whether the term is a floating-point -oo + + + + + Indicates whether the term is a floating-point NaN + + + + + Indicates whether the term is a floating-point +zero + + + + + Indicates whether the term is a floating-point -zero + + + + + Indicates whether the term is a floating-point addition term + + + + + Indicates whether the term is a floating-point subtraction term + + + + + Indicates whether the term is a floating-point negation term + + + + + Indicates whether the term is a floating-point multiplication term + + + + + Indicates whether the term is a floating-point division term + + + + + Indicates whether the term is a floating-point remainder term + + + + + Indicates whether the term is a floating-point term absolute value term + + + + + Indicates whether the term is a floating-point minimum term + + + + + Indicates whether the term is a floating-point maximum term + + + + + Indicates whether the term is a floating-point fused multiply-add term + + + + + Indicates whether the term is a floating-point square root term + + + + + Indicates whether the term is a floating-point roundToIntegral term + + + + + Indicates whether the term is a floating-point equality term + + + + + Indicates whether the term is a floating-point less-than term + + + + + Indicates whether the term is a floating-point greater-than term + + + + + Indicates whether the term is a floating-point less-than or equal term + + + + + Indicates whether the term is a floating-point greater-than or equal term + + + + + Indicates whether the term is a floating-point isNaN predicate term + + + + + Indicates whether the term is a floating-point isInf predicate term + + + + + Indicates whether the term is a floating-point isZero predicate term + + + + + Indicates whether the term is a floating-point isNormal term + + + + + Indicates whether the term is a floating-point isSubnormal predicate term + + + + + Indicates whether the term is a floating-point isNegative predicate term + + + + + Indicates whether the term is a floating-point isPositive predicate term + + + + + Indicates whether the term is a floating-point constructor term + + + + + Indicates whether the term is a floating-point conversion term + + + + + Indicates whether the term is a floating-point conversion from unsigned bit-vector term + + + + + Indicates whether the term is a floating-point conversion to unsigned bit-vector term + + + + + Indicates whether the term is a floating-point conversion to signed bit-vector term + + + + + Indicates whether the term is a floating-point conversion to real term + + + + + Indicates whether the term is a floating-point conversion to IEEE-754 bit-vector term + + + + + The de-Bruijn index of a bound variable. + + + Bound variables are indexed by de-Bruijn indices. It is perhaps easiest to explain + the meaning of de-Bruijn indices by indicating the compilation process from + non-de-Bruijn formulas to de-Bruijn format. + + abs(forall (x1) phi) = forall (x1) abs1(phi, x1, 0) + abs(forall (x1, x2) phi) = abs(forall (x1) abs(forall (x2) phi)) + abs1(x, x, n) = b_n + abs1(y, x, n) = y + abs1(f(t1,...,tn), x, n) = f(abs1(t1,x,n), ..., abs1(tn,x,n)) + abs1(forall (x1) phi, x, n) = forall (x1) (abs1(phi, x, n+1)) + + The last line is significant: the index of a bound variable is different depending + on the scope in which it appears. The deeper x appears, the higher is its + index. + + + + + Constructor for Expr + + + + + Finite-domain expressions + + + + Constructor for DatatypeExpr + + + + Finite-domain numerals + + + + + Retrieve the 64-bit unsigned integer value. + + + + + Retrieve the int value. + + + + + Retrieve the 64-bit int value. + + + + + Retrieve the int value. + + + + + Retrieve the BigInteger value. + + + + + Returns a string representation of the numeral. + + + + + Finite domain sorts. + + + + + The size of the finite domain sort. + + + + + Object for managing fixedpoints + + + + + A string that describes all available fixedpoint solver parameters. + + + + + Sets the fixedpoint solver parameters. + + + + + Retrieves parameter descriptions for Fixedpoint solver. + + + + + Assert a constraint (or multiple) into the fixedpoint solver. + + + + + Alias for Assert. + + + + + Register predicate as recursive relation. + + + + + Add rule into the fixedpoint solver. + + + + + Add table fact to the fixedpoint solver. + + + + + Query the fixedpoint solver. + A query is a conjunction of constraints. The constraints may include the recursively defined relations. + The query is satisfiable if there is an instance of the query variables and a derivation for it. + The query is unsatisfiable if there are no derivations satisfying the query variables. + + + + + Query the fixedpoint solver. + A query is an array of relations. + The query is satisfiable if there is an instance of some relation that is non-empty. + The query is unsatisfiable if there are no derivations satisfying any of the relations. + + + + + Update named rule into in the fixedpoint solver. + + + + + Retrieve satisfying instance or instances of solver, + or definitions for the recursive predicates that show unsatisfiability. + + + + + Retrieve explanation why fixedpoint engine returned status Unknown. + + + + + Retrieve the number of levels explored for a given predicate. + + + + + Retrieve the cover of a predicate. + + + + + Add property about the predicate. + The property is added at level. + + + + + Retrieve internal string representation of fixedpoint object. + + + + + Instrument the Datalog engine on which table representation to use for recursive predicate. + + + + + Convert benchmark given as set of axioms, rules and queries to a string. + + + + + Retrieve set of rules added to fixedpoint context. + + + + + Retrieve set of assertions added to fixedpoint context. + + + + + Fixedpoint statistics. + + + + + Parse an SMT-LIB2 file with fixedpoint rules. + Add the rules to the current fixedpoint context. + Return the set of queries in the file. + + + + + Similar to ParseFile. Instead it takes as argument a string. + + + + + FloatingPoint Expressions + + + + + The number of exponent bits. + + + + + The number of significand bits. + + + + Constructor for FPExpr + + + + FloatiungPoint Numerals + + + + + The sign of a floating-point numeral as a bit-vector expression + + + NaN's do not have a bit-vector sign, so they are invalid arguments. + + + + + Retrieves the sign of a floating-point literal + + + Remarks: returns true if the numeral is negative + + + + + The significand value of a floating-point numeral as a string + + + The significand s is always 0 < s < 2.0; the resulting string is long + enough to represent the real significand precisely. + + + + + The significand value of a floating-point numeral as a UInt64 + + + This function extracts the significand bits, without the + hidden bit or normalization. Throws an exception if the + significand does not fit into a UInt64. + + + + + The significand of a floating-point numeral as a bit-vector expression + + + +oo, -oo and NaN's do not have a bit-vector significand, so they are invalid arguments. + + + + + Return the (biased) exponent value of a floating-point numeral as a string + + + + + Return the exponent value of a floating-point numeral as a signed 64-bit integer + + + + + The exponent of a floating-point numeral as a bit-vector expression + + + +oo, -oo and NaN's do not have a bit-vector exponent, so they are invalid arguments. + + + + + Indicates whether the numeral is a NaN. + + + + + Indicates whether the numeral is a +oo or -oo. + + + + + Indicates whether the numeral is +zero or -zero. + + + + + Indicates whether the numeral is normal. + + + + + Indicates whether the numeral is subnormal. + + + + + Indicates whether the numeral is positive. + + + + + Indicates whether the numeral is negative. + + + + + Returns a string representation of the numeral. + + + + + FloatingPoint RoundingMode Expressions + + + + Constructor for FPRMExpr + + + + Floating-point rounding mode numerals + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToEven + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToEven + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToAway + + + + + Indicates whether the term is the floating-point rounding numeral roundNearestTiesToAway + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardPositive + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardPositive + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardNegative + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardNegative + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardZero + + + + + Indicates whether the term is the floating-point rounding numeral roundTowardZero + + + + + Returns a string representation of the numeral. + + + + Constructor for FPRMNum + + + + The FloatingPoint RoundingMode sort + + + + + FloatingPoint sort + + + + + The number of exponent bits. + + + + + The number of significand bits. + + + + + Function declarations. + + + + + Comparison operator. + + True if and share the same context and are equal, false otherwise. + + + + Comparison operator. + + True if and do not share the same context or are not equal, false otherwise. + + + + Object comparison. + + + + + A hash code. + + + + + A string representations of the function declaration. + + + + + Returns a unique identifier for the function declaration. + + + + + The arity of the function declaration + + + + + The size of the domain of the function declaration + + + + + + The domain of the function declaration + + + + + The range of the function declaration + + + + + The kind of the function declaration. + + + + + The name of the function declaration + + + + + The number of parameters of the function declaration + + + + + The parameters of the function declaration + + + + + Function declarations can have Parameters associated with them. + + + + The int value of the parameter. + + + The double value of the parameter. + + + The Symbol value of the parameter. + + + The Sort value of the parameter. + + + The AST value of the parameter. + + + The FunctionDeclaration value of the parameter. + + + The rational string value of the parameter. + + + + The kind of the parameter. + + + + + Translates (copies) the function declaration to the Context . + + A context + A copy of the function declaration which is associated with + + + + Create expression that applies function to arguments. + + + + + + + Create expression that applies function to arguments. + + + + + + + A function interpretation is represented as a finite map and an 'else' value. + Each entry in the finite map represents the value of a function given a set of arguments. + + + + + An Entry object represents an element in the finite map used to encode + a function interpretation. + + + + + Return the (symbolic) value of this entry. + + + + + The number of arguments of the entry. + + + + + The arguments of the function entry. + + + + + A string representation of the function entry. + + + + + The number of entries in the function interpretation. + + + + + The entries in the function interpretation + + + + + The (symbolic) `else' value of the function interpretation. + + + + + The arity of the function interpretation + + + + + A string representation of the function interpretation. + + + + + Global functions for Z3. + + + This (static) class contains functions that effect the behaviour of Z3 + globally across contexts, etc. + + + + + Set a global (or module) parameter, which is shared by all Z3 contexts. + + + When a Z3 module is initialized it will use the value of these parameters + when Z3_params objects are not provided. + The name of parameter can be composed of characters [a-z][A-Z], digits [0-9], '-' and '_'. + The character '.' is a delimiter (more later). + The parameter names are case-insensitive. The character '-' should be viewed as an "alias" for '_'. + Thus, the following parameter names are considered equivalent: "pp.decimal-precision" and "PP.DECIMAL_PRECISION". + This function can be used to set parameters for a specific Z3 module. + This can be done by using [module-name].[parameter-name]. + For example: + Z3_global_param_set('pp.decimal', 'true') + will set the parameter "decimal" in the module "pp" to true. + + + + + Get a global (or module) parameter. + + + Returns null if the parameter does not exist. + The caller must invoke #Z3_global_param_del_value to delete the value returned at \c param_value. + This function cannot be invoked simultaneously from different threads without synchronization. + The result string stored in param_value is stored in a shared location. + + + + + Restore the value of all global (and module) parameters. + + + This command will not affect already created objects (such as tactics and solvers) + + + + + + Enable/disable printing of warning messages to the console. + + Note that this function is static and effects the behaviour of + all contexts globally. + + + + Enable tracing messages tagged as `tag' when Z3 is compiled in debug mode. + + + It is a NOOP otherwise. + + trace tag + + + + Disable tracing messages tagged as `tag' when Z3 is compiled in debug mode. + + + It is a NOOP otherwise. + + trace tag + + + + A goal (aka problem). A goal is essentially a set + of formulas, that can be solved and/or transformed using + tactics and solvers. + + + + + The precision of the goal. + + + Goals can be transformed using over and under approximations. + An under approximation is applied when the objective is to find a model for a given goal. + An over approximation is applied when the objective is to find a proof for a given goal. + + + + + Indicates whether the goal is precise. + + + + + Indicates whether the goal is an under-approximation. + + + + + Indicates whether the goal is an over-approximation. + + + + + Indicates whether the goal is garbage (i.e., the product of over- and under-approximations). + + + + + Adds the to the given goal. + + + + + Alias for Assert. + + + + + Indicates whether the goal contains `false'. + + + + + The depth of the goal. + + + This tracks how many transformations were applied to it. + + + + + Erases all formulas from the given goal. + + + + + The number of formulas in the goal. + + + + + The formulas in the goal. + + + + + The number of formulas, subformulas and terms in the goal. + + + + + Indicates whether the goal is empty, and it is precise or the product of an under approximation. + + + + + Indicates whether the goal contains `false', and it is precise or the product of an over approximation. + + + + + Convert a model for the goal into a model of the + original goal from which this goal was derived. + + A model for g + + + + Translates (copies) the Goal to the target Context . + + + + + Simplifies the goal. + + Essentially invokes the `simplify' tactic on the goal. + + + + Goal to string conversion. + + A string representation of the Goal. + + + + Goal to DIMACS formatted string conversion. + + A string representation of the Goal. + + + + Goal to BoolExpr conversion. + + A string representation of the Goal. + + + + DecRefQueue interface + + + + + Sets the limit on numbers of objects that are kept back at GC collection. + + + + + + Int expressions + + + + Constructor for IntExpr + + + + Integer Numerals + + + + + Retrieve the 64-bit unsigned integer value. + + + + + Retrieve the int value. + + + + + Retrieve the 64-bit int value. + + + + + Retrieve the int value. + + + + + Retrieve the BigInteger value. + + + + + Returns a string representation of the numeral. + + + + + An Integer sort + + + + + Numbered symbols + + + + + The int value of the symbol. + + Throws an exception if the symbol is not of int kind. + + + + Lambda expressions. + + + + + The number of bound variables. + + + + + The symbols for the bound variables. + + + + + The sorts of the bound variables. + + + + + The body of the lambda. + + + + + Translates (copies) the lambda to the Context . + + A context + A copy of the lambda which is associated with + + + + List sorts. + + + + + The declaration of the nil function of this list sort. + + + + + The empty list. + + + + + The declaration of the isNil function of this list sort. + + + + + The declaration of the cons function of this list sort. + + + + + The declaration of the isCons function of this list sort. + + + + + + The declaration of the head function of this list sort. + + + + + The declaration of the tail function of this list sort. + + + + + Interaction logging for Z3. + + + Note that this is a global, static log and if multiple Context + objects are created, it logs the interaction with all of them. + + + + + Open an interaction log file. + + the name of the file to open + True if opening the log file succeeds, false otherwise. + + + + Closes the interaction log. + + + + + Appends the user-provided string to the interaction log. + + + + + Checks whether the interaction log is opened. + + True if the interaction log is open, false otherwise. + + + + A Model contains interpretations (assignments) of constants and functions. + + + + + Retrieves the interpretation (the assignment) of in the model. + + A Constant + An expression if the constant has an interpretation in the model, null otherwise. + + + + Retrieves the interpretation (the assignment) of in the model. + + A function declaration of zero arity + An expression if the function has an interpretation in the model, null otherwise. + + + + Retrieves the interpretation (the assignment) of a non-constant in the model. + + A function declaration of non-zero arity + A FunctionInterpretation if the function has an interpretation in the model, null otherwise. + + + + The number of constants that have an interpretation in the model. + + + + + The function declarations of the constants in the model. + + + + + Enumerate constants in model. + + + + + The number of function interpretations in the model. + + + + + The function declarations of the function interpretations in the model. + + + + + All symbols that have an interpretation in the model. + + + + + A ModelEvaluationFailedException is thrown when an expression cannot be evaluated by the model. + + + + + An exception that is thrown when model evaluation fails. + + + + + Evaluates the expression in the current model. + + + This function may fail if contains quantifiers, + is partial (MODEL_PARTIAL enabled), or if is not well-sorted. + In this case a ModelEvaluationFailedException is thrown. + + An expression + + When this flag is enabled, a model value will be assigned to any constant + or function that does not have an interpretation in the model. + + The evaluation of in the model. + + + + Alias for Eval. + + + + + Evaluate expression to a double, assuming it is a numeral already. + + + + + The number of uninterpreted sorts that the model has an interpretation for. + + + + + The uninterpreted sorts that the model has an interpretation for. + + + Z3 also provides an interpretation for uninterpreted sorts used in a formula. + The interpretation for a sort is a finite set of distinct values. We say this finite set is + the "universe" of the sort. + + + + + + + The finite set of distinct values that represent the interpretation for sort . + + + An uninterpreted sort + An array of expressions, where each is an element of the universe of + + + + Conversion of models to strings. + + A string representation of the model. + + + + Object for managing optimization context + + + + + A string that describes all available optimize solver parameters. + + + + + Sets the optimize solver parameters. + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Sets parameter on the optimize solver + + + + + Retrieves parameter descriptions for Optimize solver. + + + + + Assert a constraint (or multiple) into the optimize solver. + + + + + Assert a constraint (or multiple) into the optimize solver. + + + + + Alias for Assert. + + + + + Alias for Assert. + + + + + Assert a constraint (or multiple) into the optimize solver. + + + + + Handle to objectives returned by objective functions. + + + + + Retrieve a lower bound for the objective handle. + + + + + Retrieve an upper bound for the objective handle. + + + + + Retrieve the value of an objective. + + + + + Retrieve a lower bound for the objective handle. + + + + + Retrieve an upper bound for the objective handle. + + + + + Assert soft constraint + + + Return an objective which associates with the group of constraints. + + + + + Check satisfiability of asserted constraints. + Produce a model that (when the objectives are bounded and + don't use strict inequalities) meets the objectives. + + + + + + Creates a backtracking point. + + + + + + Backtrack one backtracking point. + + Note that an exception is thrown if Pop is called without a corresponding Push + + + + + The model of the last Check. + + + The result is null if Check was not invoked before, + if its results was not SATISFIABLE, or if model production is not enabled. + + + + + The unsat core of the last Check. + + + The unsat core is a subset of assumptions + The result is empty if Check was not invoked before, + if its results was not UNSATISFIABLE, or if core production is disabled. + + + + + Declare an arithmetical maximization objective. + Return a handle to the objective. The handle is used as + to retrieve the values of objectives after calling Check. + The expression can be either an arithmetical expression or bit-vector. + + + + + Declare an arithmetical minimization objective. + Similar to MkMaximize. + + + + + Retrieve a lower bound for the objective handle. + + + + + Retrieve an upper bound for the objective handle. + + + + + Retrieve a lower bound for the objective handle. + + + + + Retrieve an upper bound for the objective handle. + + + + + Return a string the describes why the last to check returned unknown + + + + + Print the context to a string (SMT-LIB parseable benchmark). + + + + + Parse an SMT-LIB2 file with optimization objectives and constraints. + The parsed constraints and objectives are added to the optimization context. + + + + + Similar to FromFile. Instead it takes as argument a string. + + + + + The set of asserted formulas. + + + + + The set of asserted formulas. + + + + + Optimize statistics. + + + + + A ParamDescrs describes a set of parameters. + + + + + validate a set of parameters. + + + + + Retrieve kind of parameter. + + + + + Retrieve documentation of parameter. + + + + + Retrieve all names of parameters. + + + + + The size of the ParamDescrs. + + + + + Retrieves a string representation of the ParamDescrs. + + + + + A Params objects represents a configuration in the form of Symbol/value pairs. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + Adds a parameter setting. + + + + + A string representation of the parameter set. + + + + + Patterns comprise a list of terms. The list should be + non-empty. If the list comprises of more than one term, it is + also called a multi-pattern. + + + + + The number of terms in the pattern. + + + + + The terms in the pattern. + + + + + A string representation of the pattern. + + + + + Probes are used to inspect a goal (aka problem) and collect information that may be used to decide + which solver and/or preprocessing step will be used. + The complete list of probes may be obtained using the procedures Context.NumProbes + and Context.ProbeNames. + It may also be obtained using the command (help-tactic) in the SMT 2.0 front-end. + + + + + Execute the probe over the goal. + + A probe always produce a double value. + "Boolean" probes return 0.0 for false, and a value different from 0.0 for true. + + + + Apply the probe to a goal. + + + + + Quantifier expressions. + + + + + Indicates whether the quantifier is universal. + + + + + Indicates whether the quantifier is existential. + + + + + The weight of the quantifier. + + + + + The number of patterns. + + + + + The patterns. + + + + + The number of no-patterns. + + + + + The no-patterns. + + + + + The number of bound variables. + + + + + The symbols for the bound variables. + + + + + The sorts of the bound variables. + + + + + The body of the quantifier. + + + + + Translates (copies) the quantifier to the Context . + + A context + A copy of the quantifier which is associated with + + + + Rational Numerals + + + + + The numerator of a rational numeral. + + + + + The denominator of a rational numeral. + + + + + Converts the numerator of the rational to a BigInteger + + + + + Converts the denominator of the rational to a BigInteger + + + + + Returns a string representation in decimal notation. + + The result has at most decimal places. + + + + Returns a double representing the value. + + + + + Returns a string representation of the numeral. + + + + + Real expressions + + + + Constructor for RealExpr + + + + A real sort + + + + + Regular expression expressions + + + + Constructor for ReExpr + + + + Relation sorts. + + + + + The arity of the relation sort. + + + + + The sorts of the columns of the relation sort. + + + + + A regular expression sort + + + + + Sequence expressions + + + + Constructor for SeqExpr + + + Access the nth element of a sequence + + + + A Sequence sort + + + + + Set sorts. + + + + + Solvers. + + + + + A string that describes all available solver parameters. + + + + + Sets the solver parameters. + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Sets parameter on the solver + + + + + Retrieves parameter descriptions for solver. + + + + + The current number of backtracking points (scopes). + + + + + + + Creates a backtracking point. + + + + + + Backtracks backtracking points. + + Note that an exception is thrown if is not smaller than NumScopes + + + + + Resets the Solver. + + This removes all assertions from the solver. + + + + Assert a constraint (or multiple) into the solver. + + + + + Alias for Assert. + + + + + Alias for Assert. + + + + + Assert multiple constraints into the solver, and track them (in the unsat) core + using the Boolean constants in ps. + + + This API is an alternative to with assumptions for extracting unsat cores. + Both APIs can be used in the same solver. The unsat core will contain a combination + of the Boolean variables provided using + and the Boolean literals + provided using with assumptions. + + + + + Assert a constraint into the solver, and track it (in the unsat) core + using the Boolean constant p. + + + This API is an alternative to with assumptions for extracting unsat cores. + Both APIs can be used in the same solver. The unsat core will contain a combination + of the Boolean variables provided using + and the Boolean literals + provided using with assumptions. + + + + + Load solver assertions from a file. + + + + + Load solver assertions from a string. + + + + + The number of assertions in the solver. + + + + + The set of asserted formulas. + + + + + Currently inferred units. + + + + + Checks whether the assertions in the solver are consistent or not. + + + + + + + + + + Checks whether the assertions in the solver are consistent or not. + + + + + + + + + + Retrieve fixed assignments to the set of variables in the form of consequences. + Each consequence is an implication of the form + + relevant-assumptions Implies variable = value + + where the relevant assumptions is a subset of the assumptions that are passed in + and the equality on the right side of the implication indicates how a variable + is fixed. + + + + + + + + + + The model of the last Check(params Expr[] assumptions). + + + The result is null if Check(params Expr[] assumptions) was not invoked before, + if its results was not SATISFIABLE, or if model production is not enabled. + + + + + The proof of the last Check(params Expr[] assumptions). + + + The result is null if Check(params Expr[] assumptions) was not invoked before, + if its results was not UNSATISFIABLE, or if proof production is disabled. + + + + + The unsat core of the last Check. + + + The unsat core is a subset of Assertions + The result is empty if Check was not invoked before, + if its results was not UNSATISFIABLE, or if core production is disabled. + + + + + A brief justification of why the last call to Check returned UNKNOWN. + + + + + Backtrack level that can be adjusted by conquer process + + + + + Variables available and returned by the cuber. + + + + + Return a set of cubes. + + + + + Create a clone of the current solver with respect to ctx. + + + + + Import model converter from other solver. + + + + + Solver statistics. + + + + + A string representation of the solver. + + + + + The Sort class implements type information for ASTs. + + + + + Comparison operator. + + A Sort + A Sort + True if and are from the same context + and represent the same sort; false otherwise. + + + + Comparison operator. + + A Sort + A Sort + True if and are not from the same context + or represent different sorts; false otherwise. + + + + Equality operator for objects of type Sort. + + + + + + + Hash code generation for Sorts + + A hash code + + + + Returns a unique identifier for the sort. + + + + + The kind of the sort. + + + + + The name of the sort + + + + + A string representation of the sort. + + + + + Translates (copies) the sort to the Context . + + A context + A copy of the sort which is associated with + + + + Sort constructor + + + + + Objects of this class track statistical information about solvers. + + + + + Statistical data is organized into pairs of [Key, Entry], where every + Entry is either a DoubleEntry or a UIntEntry + + + + + The key of the entry. + + + + + The uint-value of the entry. + + + + + The double-value of the entry. + + + + + True if the entry is uint-valued. + + + + + True if the entry is double-valued. + + + + + The string representation of the entry's value. + + + + + The string representation of the Entry. + + + + + A string representation of the statistical data. + + + + + The number of statistical data. + + + + + The data entries. + + + + + The statistical counters. + + + + + The value of a particular statistical counter. + + Returns null if the key is unknown. + + + + Status values. + + + + + Used to signify an unsatisfiable status. + + + + + Used to signify an unknown status. + + + + + Used to signify a satisfiable status. + + + + + Named symbols + + + + + The string value of the symbol. + + Throws an exception if the symbol is not of string kind. + + + + Symbols are used to name several term and type constructors. + + + + + The kind of the symbol (int or string) + + + + + Indicates whether the symbol is of Int kind + + + + + Indicates whether the symbol is of string kind. + + + + + A string representation of the symbol. + + + + + Equality overloading. + + + + + Equality overloading. + + + + + Object comparison. + + + + + The Symbols's hash code. + + A hash code + + + + Symbol constructor + + + + + Tactics are the basic building block for creating custom solvers for specific problem domains. + The complete list of tactics may be obtained using Context.NumTactics + and Context.TacticNames. + It may also be obtained using the command (help-tactic) in the SMT 2.0 front-end. + + + + + A string containing a description of parameters accepted by the tactic. + + + + + Retrieves parameter descriptions for Tactics. + + + + + Execute the tactic over the goal. + + + + + Apply the tactic to a goal. + + + + + Creates a solver that is implemented using the given tactic. + + + + + + DecRefQueue + + + + + Tuple sorts. + + + + + The constructor function of the tuple. + + + + + The number of fields in the tuple. + + + + + The field declarations. + + + + + Uninterpreted Sorts + + + + + Version information. + + Note that this class is static. + + + + The major version + + + + + The minor version + + + + + The build version + + + + + The revision + + + + + A full version string + + + + + A string representation of the version information. + + + + + The exception base class for error reporting from Z3 + + + + + Constructor. + + + + + Constructor. + + + + + Constructor. + + + + + Internal base class for interfacing with native Z3 objects. + Should not be used externally. + + + + + Finalizer. + + + + + Disposes of the underlying native Z3 object. + + + + Z3_lbool + + + Z3_symbol_kind + + + Z3_parameter_kind + + + Z3_sort_kind + + + Z3_ast_kind + + + Z3_decl_kind + + + Z3_param_kind + + + Z3_ast_print_mode + + + Z3_error_code + + + Z3_goal_prec + + + diff --git a/bin/com.microsoft.z3.jar b/bin/lib/com.microsoft.z3.jar similarity index 100% rename from bin/com.microsoft.z3.jar rename to bin/lib/com.microsoft.z3.jar diff --git a/bin/input.in b/bin/lib/input.in similarity index 100% rename from bin/input.in rename to bin/lib/input.in diff --git a/bin/lib/libz3.a b/bin/lib/libz3.a new file mode 100644 index 00000000..d06c2797 Binary files /dev/null and b/bin/lib/libz3.a differ diff --git a/bin/libz3.dll b/bin/lib/libz3.dll similarity index 100% rename from bin/libz3.dll rename to bin/lib/libz3.dll diff --git a/bin/lib/libz3.dylib b/bin/lib/libz3.dylib new file mode 100644 index 00000000..249f1bf6 Binary files /dev/null and b/bin/lib/libz3.dylib differ diff --git a/bin/libz3.lib b/bin/lib/libz3.lib similarity index 100% rename from bin/libz3.lib rename to bin/lib/libz3.lib diff --git a/bin/lib/libz3.so b/bin/lib/libz3.so new file mode 100644 index 00000000..e6897f94 Binary files /dev/null and b/bin/lib/libz3.so differ diff --git a/bin/libz3java.dll b/bin/lib/libz3java.dll similarity index 100% rename from bin/libz3java.dll rename to bin/lib/libz3java.dll diff --git a/bin/lib/libz3java.dylib b/bin/lib/libz3java.dylib new file mode 100644 index 00000000..08a8dd39 Binary files /dev/null and b/bin/lib/libz3java.dylib differ diff --git a/bin/libz3java.lib b/bin/lib/libz3java.lib similarity index 100% rename from bin/libz3java.lib rename to bin/lib/libz3java.lib diff --git a/bin/lib/libz3java.so b/bin/lib/libz3java.so new file mode 100644 index 00000000..10096b23 Binary files /dev/null and b/bin/lib/libz3java.so differ diff --git a/bin/msvcp140.dll b/bin/lib/msvcp140.dll similarity index 100% rename from bin/msvcp140.dll rename to bin/lib/msvcp140.dll diff --git a/bin/msvcp140_1.dll b/bin/lib/msvcp140_1.dll similarity index 100% rename from bin/msvcp140_1.dll rename to bin/lib/msvcp140_1.dll diff --git a/bin/msvcp140_2.dll b/bin/lib/msvcp140_2.dll similarity index 100% rename from bin/msvcp140_2.dll rename to bin/lib/msvcp140_2.dll diff --git a/bin/vcomp140.dll b/bin/lib/vcomp140.dll similarity index 100% rename from bin/vcomp140.dll rename to bin/lib/vcomp140.dll diff --git a/bin/vcruntime140.dll b/bin/lib/vcruntime140.dll similarity index 100% rename from bin/vcruntime140.dll rename to bin/lib/vcruntime140.dll diff --git a/bin/lib/z3 b/bin/lib/z3 new file mode 100644 index 00000000..1ed4e82a Binary files /dev/null and b/bin/lib/z3 differ diff --git a/input/test.alk b/input/test.alk index 9601d92d..5c911dc1 100644 --- a/input/test.alk +++ b/input/test.alk @@ -76,10 +76,4 @@ executia3 -> true // 1) evaluare argumente si initializare parametrii de intrare // 2) assert r // 3) havoc output, modifies - // 4) assume e - - - -// punem toate instructiunile globale intr-o metoda main cu specificatii (true / true) -// adaugarea @Trusted -// linia invariantului in loc de linia while-ului (in cazul mesajelor) -> vezi contextul de parsare \ No newline at end of file + // 4) assume e \ No newline at end of file diff --git a/input/test5.alk b/input/test5.alk index f8a4adfe..7e71b003 100644 --- a/input/test5.alk +++ b/input/test5.alk @@ -1,6 +1,18 @@ -a = 0; -do +a = [1, 2, 3, 4]; +i = 0; +minim = a[0]; + +while (i < a.size()) { - a++; -} while (a < 2); + if (a[i] < minim) + { + minim = a[i]; + } + i++; +} + +print(minim); + + + diff --git a/input/test7.alk b/input/test7.alk new file mode 100644 index 00000000..b1ec961c --- /dev/null +++ b/input/test7.alk @@ -0,0 +1,28 @@ +findMin(a : array) : int +ensures forall j : int :: 0 <= j && j < a.size() ==> result <= a[j] +ensures exists j : int :: 0 <= j && j < a.size() ==> result == a[j] +{ + i = 0; + minim = a[0]; + + while (i < a.size()) + invariant i <= a.size() + invariant forall j : int :: 0 <= j && j < i ==> minim <= a[j] + modifies i, minim + { + if (a[i] < minim) + { + minim = a[i]; + } + i++; + } + + return minim; +} + +symbolic $a : array; +a = $a; +x = findMin(a); + + + diff --git a/lib/Microsoft.Z3.dll b/lib/Microsoft.Z3.dll new file mode 100644 index 00000000..a3f8ff99 Binary files /dev/null and b/lib/Microsoft.Z3.dll differ diff --git a/lib/libz3.dll b/lib/libz3.dll new file mode 100644 index 00000000..f6551e27 Binary files /dev/null and b/lib/libz3.dll differ diff --git a/lib/libz3.lib b/lib/libz3.lib new file mode 100644 index 00000000..a9d26571 Binary files /dev/null and b/lib/libz3.lib differ diff --git a/lib/libz3java.dll b/lib/libz3java.dll new file mode 100644 index 00000000..72c1ef4c Binary files /dev/null and b/lib/libz3java.dll differ diff --git a/lib/libz3java.lib b/lib/libz3java.lib new file mode 100644 index 00000000..5c5cb6f0 Binary files /dev/null and b/lib/libz3java.lib differ diff --git a/lib/msvcp140.dll b/lib/msvcp140.dll new file mode 100644 index 00000000..98313d4c Binary files /dev/null and b/lib/msvcp140.dll differ diff --git a/lib/msvcp140_1.dll b/lib/msvcp140_1.dll new file mode 100644 index 00000000..c0253df9 Binary files /dev/null and b/lib/msvcp140_1.dll differ diff --git a/lib/msvcp140_2.dll b/lib/msvcp140_2.dll new file mode 100644 index 00000000..93f00f5a Binary files /dev/null and b/lib/msvcp140_2.dll differ diff --git a/lib/vcomp140.dll b/lib/vcomp140.dll new file mode 100644 index 00000000..6a74c96f Binary files /dev/null and b/lib/vcomp140.dll differ diff --git a/lib/vcruntime140.dll b/lib/vcruntime140.dll new file mode 100644 index 00000000..34a0e725 Binary files /dev/null and b/lib/vcruntime140.dll differ diff --git a/output.log b/output.log index 0fac797b..7edcc915 100644 --- a/output.log +++ b/output.log @@ -1,9 +1,114 @@ -1 -sigma |-> ["a", "b", "c"] -input |-> "(a.b+c)*.(b.a)" -ast |-> ["_._", < ["_*", < ["_+_", < ["_._", < ["a", < >], ["b", < >] >], ["c", < >] >] >], ["_._", < ["b", < >], ["a", < >] >] >] -s |-> ["b", "b", "a", "a", "a", "b", "b", "a", "c", "c"] -index |-> 14 -am |-> [{< 0, "a", 1 >, < 0, "b", 2 >, < 0, "c", 0 >, < 1, "b", 0 >, < 2, "a", 3 >}, < [0, ["_._", < ["_*", < ["_+_", < ["_._", < ["a", < >], ["b", < >] >], ["c", < >] >] >], ["_._", < ["b", < >], ["a", < >] >] >], "acc"], [1, ["_._", < ["_._", < ["b", < >], ["_*", < ["_+_", < ["_._", < ["a", < >], ["b", < >] >], ["c", < >] >] >] >], ["_._", < ["b", < >], ["a", < >] >] >], ""], [2, ["a", < >], ""], [3, ["", < >], "acc"] >] -subj |-> "bbaaabbacc" +=======================CFG======================== + +"input" +"a=[1,2,3,4];" +"i=0;" +"minim=a[0];" +"while (i(PathCondition.java:59) + at dataflow.domain.ExecutionPath.(ProgramContext.java:220) + at dataflow.domain.ProgramContext.(ProgramContext.java:40) + at dataflow.wcet.SeqWCETLattice.getLUB(SeqWCETLattice.java:24) + at dataflow.wcet.SeqWCETLattice.getLUB(SeqWCETLattice.java:9) + at dataflow.worklist.WorklistFlow.execute(WorklistFlow.java:42) + at dataflow.Dataflow.run(Dataflow.java:27) +minim=a[i]; -> + +i++; -> + +output -> + +minim=a[0]; -> +{ + Environment: + a |-> [1, 2, 3, 4] + i |-> 0 + Path Condition: + true +} + +input -> +{ + Environment: + + Path Condition: + true +} + +i=0; -> +{ + Environment: + a |-> [1, 2, 3, 4] + Path Condition: + true +} + +a=[1,2,3,4]; -> +{ + Environment: + + Path Condition: + true +} + +print(minim); -> + +if (a[i] + +while (i +{ + Environment: + a |-> [1, 2, 3, 4] + minim |-> 1 + i |-> 0 + Path Condition: + true +} + +===================Loop mapping=================== + +line 5 i l_0 + +====================Recurrence==================== + +Loop 0: + a: + a_l0(0) = [1, 2, 3, 4] when true + + minim: + minim_l0(0) = 1 when true + + i: + i_l0(0) = 0 when true diff --git a/src/main/java/ast/VirtualAST.java b/src/main/java/ast/VirtualAST.java index 53739561..d107f622 100644 --- a/src/main/java/ast/VirtualAST.java +++ b/src/main/java/ast/VirtualAST.java @@ -1,5 +1,8 @@ package ast; +import visitor.ifaces.VisitorIface; +import visitor.ifaces.expr.VirtualVisitorIface; + import java.util.HashMap; import java.util.Map; @@ -18,6 +21,15 @@ public static int getASTId(AST tree) return astIdMapping.get(tree); } + @Override + public T accept(VisitorIface visitor) + { + if (visitor instanceof VirtualVisitorIface) + return ((VirtualVisitorIface) visitor).visit(this); + + return super.accept(visitor); + } + public static String getMappingAsString() { StringBuilder sb = new StringBuilder(); diff --git a/src/main/java/ast/enums/Primitive.java b/src/main/java/ast/enums/Primitive.java index 35002eb3..274515b3 100644 --- a/src/main/java/ast/enums/Primitive.java +++ b/src/main/java/ast/enums/Primitive.java @@ -1,5 +1,5 @@ package ast.enums; public enum Primitive { - INT, FLOAT, BOOL, STRING, ARRAY, LIST, SET, STRUCTURE, UNKNOWN + INT, FLOAT, BOOL, STRING, ARRAY, LIST, SET, STRUCTURE, UNKNOWN, MAP; } diff --git a/src/main/java/ast/expr/MapAST.java b/src/main/java/ast/expr/MapAST.java new file mode 100644 index 00000000..b39000f3 --- /dev/null +++ b/src/main/java/ast/expr/MapAST.java @@ -0,0 +1,41 @@ +package ast.expr; + +import ast.AST; +import ast.type.DataTypeAST; +import ast.type.DataTypeProvider; +import org.antlr.v4.runtime.ParserRuleContext; +import util.exception.InternalException; +import visitor.ifaces.VisitorIface; +import visitor.ifaces.expr.MapVisitorIface; +import visitor.ifaces.expr.StructVisitorIface; + +public class MapAST +extends ExpressionAST +{ + + public MapAST(ParserRuleContext ctx) + { + super(ctx); + } + + @Override + public DataTypeAST getDataType(DataTypeProvider dtp) + { + throw new InternalException("Can't detect data type for structures."); + } + + @Override + public String toString() + { + return "{" + AST.getSV(this, " ") + "}"; + } + + @Override + public T accept(VisitorIface visitor) + { + if (visitor instanceof MapVisitorIface) + return ((MapVisitorIface) visitor).visit(this); + + return super.accept(visitor); + } +} diff --git a/src/main/java/control/parser/CFGExprInterpreter.java b/src/main/java/control/parser/CFGExprInterpreter.java index 2d9e9733..69eabf0a 100644 --- a/src/main/java/control/parser/CFGExprInterpreter.java +++ b/src/main/java/control/parser/CFGExprInterpreter.java @@ -1,6 +1,7 @@ package control.parser; import ast.AST; +import ast.enums.ContextVar; import ast.enums.FOL; import ast.enums.Primitive; import visitor.stateful.StatefulExpressionInterpreter; @@ -75,6 +76,12 @@ public CFGState interpretFol(FOL equiv, AST ast, CFGPayload payload) return null; } + @Override + public CFGState interpretContextVar(ContextVar var, AST ast, CFGPayload payload) + { + return null; + } + @Override public void interpretAnno(AST ast, CFGPayload payload) { diff --git a/src/main/java/dataflow/domain/ProgramContext.java b/src/main/java/dataflow/domain/ProgramContext.java index af3cf9b6..44657131 100644 --- a/src/main/java/dataflow/domain/ProgramContext.java +++ b/src/main/java/dataflow/domain/ProgramContext.java @@ -230,13 +230,13 @@ public void run(AST tree, EdgeData data) { if (data.getCondition()) { - this.pc.add(SymbolicValue.toSymbolic(value)); + this.pc.add(SymbolicValue.toSymbolic(value), false); } else { SymbolicValue symVal = SymbolicValue.toSymbolic(value); AST negatedAst = UnaryAST.createUnary(Operator.NOT, symVal.toAST()); - this.pc.add(new SymbolicValue(negatedAst)); + this.pc.add(new SymbolicValue(negatedAst), false); } } } diff --git a/src/main/java/execution/interpreter/BaseStatefulExpressionInterpreter.java b/src/main/java/execution/interpreter/BaseStatefulExpressionInterpreter.java index 5050e7a6..7fb458bb 100644 --- a/src/main/java/execution/interpreter/BaseStatefulExpressionInterpreter.java +++ b/src/main/java/execution/interpreter/BaseStatefulExpressionInterpreter.java @@ -113,7 +113,12 @@ public ExecutionState interpretComposite(Primitive primitive, AST ast, Execution case MAP_SPEC: return new IterableWithMapSpecState(primitive, ast, payload); case COMPONENTS: - return new BaseStructWithCompsState(ast, payload); + { + if (primitive == Primitive.STRUCTURE) + return new BaseStructWithCompsState(ast, payload); + else + return new BaseMapWithCompsState(ast, payload); + } default: throw new InternalException("Unrecognized compound data type representation: " + repr); } diff --git a/src/main/java/execution/interpreter/SymbolicStatefulExpressionInterpreter.java b/src/main/java/execution/interpreter/SymbolicStatefulExpressionInterpreter.java index cd94e284..62fdf31b 100644 --- a/src/main/java/execution/interpreter/SymbolicStatefulExpressionInterpreter.java +++ b/src/main/java/execution/interpreter/SymbolicStatefulExpressionInterpreter.java @@ -101,6 +101,7 @@ public ExecutionState interpretComposite(Primitive primitive, AST ast, Execution case FILTER_SPEC: case EXPRESSIONS: case COMPONENTS: + case MAP_SPEC: return baseDelegate.interpretComposite(primitive, ast, payload); case INTERVAL: if (primitive == Primitive.ARRAY) @@ -108,8 +109,6 @@ public ExecutionState interpretComposite(Primitive primitive, AST ast, Execution return new SymbolicIntervalState(primitive, ast, payload); } return baseDelegate.interpretComposite(primitive, ast, payload); - case MAP_SPEC: - return new IterableWithMapSpecState(primitive, ast, payload); default: throw new InternalException("Unrecognized compound data type representation: " + repr); } diff --git a/src/main/java/execution/parser/constants/Constants.java b/src/main/java/execution/parser/constants/Constants.java index a3cf2d01..7b605b98 100644 --- a/src/main/java/execution/parser/constants/Constants.java +++ b/src/main/java/execution/parser/constants/Constants.java @@ -2,7 +2,7 @@ public class Constants { - public static final String VERSION = "3.0"; + public static final String VERSION = "3.1"; public static int MAX_DECIMALS = 10; public static int MAX_ARRAY = 1000000000; public final static boolean DEBUG = false; diff --git a/src/main/java/execution/state/expression/BaseBinaryOperatorState.java b/src/main/java/execution/state/expression/BaseBinaryOperatorState.java index 085a59a6..b3757e7e 100644 --- a/src/main/java/execution/state/expression/BaseBinaryOperatorState.java +++ b/src/main/java/execution/state/expression/BaseBinaryOperatorState.java @@ -120,7 +120,7 @@ protected Storable interpretResult(Operator op, Storable current, Storable next) catch (InvocationTargetException e) { if (e.getCause() instanceof AlkException) - super.handle(new AlkException(e.getCause().getMessage())); + super.handle((AlkException) e.getCause()); Throwable tr = e.getTargetException(); if (tr instanceof AlkException) diff --git a/src/main/java/execution/state/expression/BaseMapWithCompsState.java b/src/main/java/execution/state/expression/BaseMapWithCompsState.java new file mode 100644 index 00000000..9d0f97c7 --- /dev/null +++ b/src/main/java/execution/state/expression/BaseMapWithCompsState.java @@ -0,0 +1,55 @@ +package execution.state.expression; + +import ast.AST; +import execution.ExecutionPayload; +import execution.ExecutionResult; +import execution.exhaustive.SplitMapper; +import execution.parser.env.Location; +import execution.state.ExecutionState; +import execution.types.AlkMap; + +public class BaseMapWithCompsState +extends ExecutionState +{ + private AlkMap mapping = new AlkMap(); + private int step = 0; + private Location key; + + public BaseMapWithCompsState(AST tree, ExecutionPayload executionPayload) { + super(tree, executionPayload); + } + + @Override + public ExecutionState makeStep() + { + if (step == tree.getChildCount()) + { + setResult(new ExecutionResult(generator.generate(mapping))); + return null; + } + + return request(tree.getChild(step++)); + } + + @Override + public void assign(ExecutionResult result) + { + if (step % 2 == 1) + { + key = generator.generate(result.getValue().toRValue()); + } + else + { + mapping.put(key, generator.generate(result.getValue().toRValue())); + } + } + + @Override + public ExecutionState clone(SplitMapper sm) { + BaseMapWithCompsState copy = new BaseMapWithCompsState(tree, payload.clone(sm)); + copy.mapping = (AlkMap) this.mapping.weakClone(sm.getLocationMapper()); + copy.step = this.step; + copy.key = key != null ? sm.getLocationMapper().get(key) : null; + return super.decorate(copy, sm); + } +} diff --git a/src/main/java/execution/state/expression/EmptyCompositeState.java b/src/main/java/execution/state/expression/EmptyCompositeState.java index 20379c47..e648c4b1 100644 --- a/src/main/java/execution/state/expression/EmptyCompositeState.java +++ b/src/main/java/execution/state/expression/EmptyCompositeState.java @@ -6,6 +6,7 @@ import execution.exhaustive.SplitMapper; import execution.state.ExecutionState; import execution.state.PrimitiveState; +import execution.types.AlkMap; import execution.types.alkArray.AlkArray; import execution.types.alkList.AlkList; import execution.types.alkSet.AlkSet; @@ -36,6 +37,8 @@ protected Storable requireResult() return getStore().generate(new AlkSet()); case STRUCTURE: return getStore().generate(new AlkStructure()); + case MAP: + return getStore().generate(new AlkMap()); default: throw new InternalException("Unrecognized primitive type for this compound representation!"); } diff --git a/src/main/java/execution/types/AlkMap.java b/src/main/java/execution/types/AlkMap.java new file mode 100644 index 00000000..8b5f8028 --- /dev/null +++ b/src/main/java/execution/types/AlkMap.java @@ -0,0 +1,210 @@ +package execution.types; + +import ast.AST; +import execution.parser.env.Location; +import execution.parser.env.LocationMapper; +import execution.parser.exceptions.AlkException; +import execution.parser.exceptions.NotImplementedException; +import execution.types.alkBool.AlkBool; +import execution.types.alkInt.AlkInt; +import util.lambda.LocationGenerator; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +import static execution.parser.exceptions.AlkException.ERR_EQUAL_STRUCT; + +public class AlkMap +extends AlkValue +{ + private final Map mapping = new HashMap<>(); + + public AlkMap() { + + } + + @Override + public String toString() + { + StringBuilder returnable = new StringBuilder("{"); + if (mapping.isEmpty()) + { + return "{|->}"; + } + + Map.Entry act = null; + Iterator > it = mapping.entrySet().iterator(); + while (it.hasNext()) + { + act = it.next(); + if (!it.hasNext()) break; + returnable.append(act.getKey().toRValue().toString()); + returnable.append(" |-> "); + returnable.append(act.getValue().toRValue().toString()).append(" "); + } + + if (mapping.size() > 0 && act != null) + { + returnable.append(act.getKey().toRValue().toString()); + returnable.append(" |-> "); + returnable.append(act.getValue().toRValue().toString()); + } + return returnable + "}"; + } + + @Override + public AlkValue weakClone(LocationMapper locMapping) + { + AlkMap copy = new AlkMap(); + for (Map.Entry entry : mapping.entrySet()) + { + copy.mapping.put(locMapping.get(entry.getKey()), locMapping.get(entry.getValue())); + } + return copy; + } + + @Override + public AlkValue clone(LocationGenerator generator) + { + AlkMap copy = new AlkMap(); + for (Map.Entry entry : mapping.entrySet()) + { + copy.mapping.put( + generator.generate(entry.getKey().toRValue().clone(generator)), + generator.generate(entry.getValue().toRValue().clone(generator)) + ); + } + return copy; + } + + @Override + public AlkBool equal(AlkValue operand) + { + if (!(operand instanceof AlkMap)) + throw new AlkException(ERR_EQUAL_STRUCT); + + AlkMap op = (AlkMap) operand; + + if (mapping.size() != op.mapping.size()) + { + return new AlkBool(false); + } + + for (Location key : mapping.keySet()) + { + boolean has = false; + for (Map.Entry entry : op.mapping.entrySet()) + { + if (((AlkValue) entry.getKey().toRValue()).equal((AlkValue) key.toRValue()).isTrue()) + { + has = true; + break; + } + } + if (!has) + { + return new AlkBool(false); + } + + AlkValue a = (AlkValue) mapping.get(key).toRValue(); + AlkValue b = (AlkValue) op.mapping.get(key).toRValue(); + + try + { + if (!a.equal(b).isTrue()) + { + return new AlkBool(false); + } + } + catch (AlkException e) + { + return new AlkBool(false); + } + } + + return new AlkBool(true); + } + + @Override + public AlkBool lower(AlkValue operand) + { + if (!(operand instanceof AlkMap)) + throw new AlkException("The map can be a value in a relational (<) expression only if the second operand is a map."); + AlkMap op = (AlkMap) operand; + return new AlkBool(this.toString().compareTo(op.toString()) < 0); + } + + @Override + public boolean isFullConcrete() + { + for (Location loc : mapping.keySet()) + { + if (loc.isUnknown()) continue; + if (loc.toRValue() instanceof ConcreteValue && ((ConcreteValue) loc.toRValue()).isFullConcrete()) continue; + return false; + } + for (Location loc : mapping.values()) + { + if (loc.isUnknown()) continue; + if (loc.toRValue() instanceof ConcreteValue && ((ConcreteValue) loc.toRValue()).isFullConcrete()) continue; + return false; + } + return true; + } + + @Override + public AST toAST() + { + throw new NotImplementedException("Can't convert to AST an AlkMap"); + } + + @Override + public Location bracket(AlkValue operand, LocationGenerator generator) + { + return get(operand, generator); + } + + public Location get(AlkValue operand, LocationGenerator generator) + { + for (Map.Entry loc : mapping.entrySet()) + { + try + { + if (((AlkValue) loc.getKey().toRValue()).equal(operand).isTrue()) + { + return loc.getValue(); + } + } + catch (AlkException ignored) + { + + } + } + Location loc = generator.generate(null); + put(generator.generate(operand.clone(generator)), loc); + return loc; + } + + public void put(Location key, Location value) + { + for (Location loc : mapping.keySet()) + { + try + { + if (((AlkValue) loc.toRValue()).equal((AlkValue) key.toRValue()).isTrue()) + { + mapping.remove(loc); + mapping.put(key, value); + return; + } + } + catch (AlkException ignored) + { + + } + } + + mapping.put(key, value); + } +} diff --git a/src/main/java/execution/types/alkArray/AlkArray.java b/src/main/java/execution/types/alkArray/AlkArray.java index 7948f572..7c2136f8 100644 --- a/src/main/java/execution/types/alkArray/AlkArray.java +++ b/src/main/java/execution/types/alkArray/AlkArray.java @@ -246,7 +246,8 @@ public void addAll(List locs) { } @Override - public Location bracket(AlkValue operand, LocationGenerator generator) { + public Location bracket(AlkValue operand, LocationGenerator generator) + { if (!(operand instanceof AlkInt)) { throw new AlkException("Can't retrieve record from array at non-integer position!"); diff --git a/src/main/java/execution/types/alkStructure/AlkStructure.java b/src/main/java/execution/types/alkStructure/AlkStructure.java index 552989eb..f3af9936 100644 --- a/src/main/java/execution/types/alkStructure/AlkStructure.java +++ b/src/main/java/execution/types/alkStructure/AlkStructure.java @@ -143,7 +143,7 @@ public AlkBool lower(AlkValue operand) @Override public AST toAST() { - throw new NotImplementedException("Can't convert to AST an AlkList"); + throw new NotImplementedException("Can't convert to AST an AlkStructure"); } @Override diff --git a/src/main/java/grammar/alk.interp b/src/main/java/grammar/alk.interp index e9c40925..28ec9093 100644 --- a/src/main/java/grammar/alk.interp +++ b/src/main/java/grammar/alk.interp @@ -35,6 +35,7 @@ null 'failure' 'continue' 'break' +'emptyMap' 'emptySet' 'emptyList' 'emptyStructure' @@ -173,6 +174,7 @@ UNTIL FAILURE CONTINUE BREAK +EMPTYMAP EMPTYSET EMPTYLIST EMPTYSTRUCTURE @@ -326,6 +328,8 @@ list structure component set +mapping +mapping_component function_call builtin_function builtin_method @@ -336,4 +340,4 @@ configuration atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 137, 747, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 3, 2, 5, 2, 120, 10, 2, 3, 2, 3, 2, 3, 3, 6, 3, 125, 10, 3, 13, 3, 14, 3, 126, 3, 4, 3, 4, 3, 4, 5, 4, 132, 10, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 5, 4, 173, 10, 4, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 7, 7, 185, 10, 7, 12, 7, 14, 7, 188, 11, 7, 3, 8, 3, 8, 3, 8, 3, 8, 7, 8, 194, 10, 8, 12, 8, 14, 8, 197, 11, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 5, 12, 217, 10, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 227, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 234, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 7, 14, 242, 10, 14, 12, 14, 14, 14, 245, 11, 14, 3, 14, 3, 14, 3, 14, 3, 14, 7, 14, 251, 10, 14, 12, 14, 14, 14, 254, 11, 14, 5, 14, 256, 10, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 274, 10, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 7, 19, 297, 10, 19, 12, 19, 14, 19, 300, 11, 19, 5, 19, 302, 10, 19, 3, 19, 3, 19, 3, 19, 5, 19, 307, 10, 19, 3, 19, 3, 19, 3, 19, 3, 19, 7, 19, 313, 10, 19, 12, 19, 14, 19, 316, 11, 19, 5, 19, 318, 10, 19, 3, 19, 3, 19, 7, 19, 322, 10, 19, 12, 19, 14, 19, 325, 11, 19, 3, 19, 3, 19, 7, 19, 329, 10, 19, 12, 19, 14, 19, 332, 11, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 21, 3, 21, 3, 22, 5, 22, 341, 10, 22, 3, 22, 3, 22, 3, 22, 5, 22, 346, 10, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 7, 23, 364, 10, 23, 12, 23, 14, 23, 367, 11, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 7, 23, 380, 10, 23, 12, 23, 14, 23, 383, 11, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 389, 10, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 396, 10, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 404, 10, 25, 3, 26, 3, 26, 3, 26, 7, 26, 409, 10, 26, 12, 26, 14, 26, 412, 11, 26, 3, 27, 3, 27, 3, 27, 7, 27, 417, 10, 27, 12, 27, 14, 27, 420, 11, 27, 3, 28, 3, 28, 3, 28, 7, 28, 425, 10, 28, 12, 28, 14, 28, 428, 11, 28, 3, 29, 3, 29, 3, 29, 7, 29, 433, 10, 29, 12, 29, 14, 29, 436, 11, 29, 3, 30, 3, 30, 3, 30, 7, 30, 441, 10, 30, 12, 30, 14, 30, 444, 11, 30, 3, 31, 3, 31, 3, 31, 7, 31, 449, 10, 31, 12, 31, 14, 31, 452, 11, 31, 3, 32, 3, 32, 3, 32, 7, 32, 457, 10, 32, 12, 32, 14, 32, 460, 11, 32, 3, 33, 3, 33, 3, 33, 7, 33, 465, 10, 33, 12, 33, 14, 33, 468, 11, 33, 3, 34, 3, 34, 3, 34, 7, 34, 473, 10, 34, 12, 34, 14, 34, 476, 11, 34, 3, 35, 3, 35, 3, 35, 7, 35, 481, 10, 35, 12, 35, 14, 35, 484, 11, 35, 3, 36, 3, 36, 3, 36, 7, 36, 489, 10, 36, 12, 36, 14, 36, 492, 11, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 5, 37, 499, 10, 37, 3, 38, 3, 38, 7, 38, 503, 10, 38, 12, 38, 14, 38, 506, 11, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 7, 39, 522, 10, 39, 12, 39, 14, 39, 525, 11, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 540, 10, 40, 3, 41, 3, 41, 3, 42, 3, 42, 5, 42, 546, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 553, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 559, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 565, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 584, 10, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 7, 48, 594, 10, 48, 12, 48, 14, 48, 597, 11, 48, 5, 48, 599, 10, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 5, 48, 606, 10, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 7, 49, 617, 10, 49, 12, 49, 14, 49, 620, 11, 49, 5, 49, 622, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 629, 10, 49, 3, 50, 3, 50, 6, 50, 633, 10, 50, 13, 50, 14, 50, 634, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 643, 10, 50, 5, 50, 645, 10, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 7, 52, 660, 10, 52, 12, 52, 14, 52, 663, 11, 52, 5, 52, 665, 10, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 5, 52, 672, 10, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 7, 53, 680, 10, 53, 12, 53, 14, 53, 683, 11, 53, 5, 53, 685, 10, 53, 3, 53, 5, 53, 688, 10, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 7, 54, 695, 10, 54, 12, 54, 14, 54, 698, 11, 54, 5, 54, 700, 10, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 7, 55, 709, 10, 55, 12, 55, 14, 55, 712, 11, 55, 5, 55, 714, 10, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 731, 10, 56, 3, 57, 3, 57, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 7, 59, 740, 10, 59, 12, 59, 14, 59, 743, 11, 59, 3, 59, 3, 59, 3, 59, 2, 3, 76, 60, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 2, 15, 3, 2, 41, 42, 3, 2, 111, 112, 3, 2, 107, 110, 3, 2, 93, 95, 4, 2, 44, 44, 128, 128, 3, 2, 121, 122, 4, 2, 103, 104, 114, 115, 3, 2, 116, 118, 4, 2, 100, 101, 105, 106, 4, 2, 114, 116, 125, 125, 3, 2, 100, 101, 8, 2, 45, 56, 65, 65, 67, 67, 69, 69, 77, 77, 83, 86, 8, 2, 59, 59, 61, 61, 63, 64, 66, 66, 70, 76, 78, 82, 2, 797, 2, 119, 3, 2, 2, 2, 4, 124, 3, 2, 2, 2, 6, 172, 3, 2, 2, 2, 8, 174, 3, 2, 2, 2, 10, 177, 3, 2, 2, 2, 12, 180, 3, 2, 2, 2, 14, 189, 3, 2, 2, 2, 16, 198, 3, 2, 2, 2, 18, 203, 3, 2, 2, 2, 20, 207, 3, 2, 2, 2, 22, 214, 3, 2, 2, 2, 24, 233, 3, 2, 2, 2, 26, 235, 3, 2, 2, 2, 28, 259, 3, 2, 2, 2, 30, 266, 3, 2, 2, 2, 32, 275, 3, 2, 2, 2, 34, 285, 3, 2, 2, 2, 36, 291, 3, 2, 2, 2, 38, 335, 3, 2, 2, 2, 40, 337, 3, 2, 2, 2, 42, 340, 3, 2, 2, 2, 44, 388, 3, 2, 2, 2, 46, 395, 3, 2, 2, 2, 48, 397, 3, 2, 2, 2, 50, 405, 3, 2, 2, 2, 52, 413, 3, 2, 2, 2, 54, 421, 3, 2, 2, 2, 56, 429, 3, 2, 2, 2, 58, 437, 3, 2, 2, 2, 60, 445, 3, 2, 2, 2, 62, 453, 3, 2, 2, 2, 64, 461, 3, 2, 2, 2, 66, 469, 3, 2, 2, 2, 68, 477, 3, 2, 2, 2, 70, 485, 3, 2, 2, 2, 72, 498, 3, 2, 2, 2, 74, 500, 3, 2, 2, 2, 76, 507, 3, 2, 2, 2, 78, 539, 3, 2, 2, 2, 80, 541, 3, 2, 2, 2, 82, 545, 3, 2, 2, 2, 84, 552, 3, 2, 2, 2, 86, 558, 3, 2, 2, 2, 88, 564, 3, 2, 2, 2, 90, 566, 3, 2, 2, 2, 92, 583, 3, 2, 2, 2, 94, 605, 3, 2, 2, 2, 96, 628, 3, 2, 2, 2, 98, 644, 3, 2, 2, 2, 100, 646, 3, 2, 2, 2, 102, 671, 3, 2, 2, 2, 104, 687, 3, 2, 2, 2, 106, 689, 3, 2, 2, 2, 108, 703, 3, 2, 2, 2, 110, 730, 3, 2, 2, 2, 112, 732, 3, 2, 2, 2, 114, 734, 3, 2, 2, 2, 116, 741, 3, 2, 2, 2, 118, 120, 5, 4, 3, 2, 119, 118, 3, 2, 2, 2, 119, 120, 3, 2, 2, 2, 120, 121, 3, 2, 2, 2, 121, 122, 7, 2, 2, 3, 122, 3, 3, 2, 2, 2, 123, 125, 5, 6, 4, 2, 124, 123, 3, 2, 2, 2, 125, 126, 3, 2, 2, 2, 126, 124, 3, 2, 2, 2, 126, 127, 3, 2, 2, 2, 127, 5, 3, 2, 2, 2, 128, 173, 5, 36, 19, 2, 129, 131, 7, 32, 2, 2, 130, 132, 5, 44, 23, 2, 131, 130, 3, 2, 2, 2, 131, 132, 3, 2, 2, 2, 132, 133, 3, 2, 2, 2, 133, 173, 7, 126, 2, 2, 134, 135, 5, 24, 13, 2, 135, 136, 7, 126, 2, 2, 136, 173, 3, 2, 2, 2, 137, 138, 7, 33, 2, 2, 138, 173, 7, 126, 2, 2, 139, 140, 7, 35, 2, 2, 140, 173, 7, 126, 2, 2, 141, 142, 7, 36, 2, 2, 142, 173, 7, 126, 2, 2, 143, 144, 7, 37, 2, 2, 144, 173, 7, 126, 2, 2, 145, 173, 5, 22, 12, 2, 146, 173, 5, 18, 10, 2, 147, 148, 5, 20, 11, 2, 148, 149, 7, 126, 2, 2, 149, 173, 3, 2, 2, 2, 150, 173, 5, 26, 14, 2, 151, 152, 5, 28, 15, 2, 152, 153, 7, 126, 2, 2, 153, 173, 3, 2, 2, 2, 154, 173, 5, 30, 16, 2, 155, 173, 5, 32, 17, 2, 156, 173, 5, 34, 18, 2, 157, 158, 5, 44, 23, 2, 158, 159, 7, 126, 2, 2, 159, 173, 3, 2, 2, 2, 160, 161, 5, 14, 8, 2, 161, 162, 7, 126, 2, 2, 162, 173, 3, 2, 2, 2, 163, 164, 5, 12, 7, 2, 164, 165, 7, 126, 2, 2, 165, 173, 3, 2, 2, 2, 166, 167, 5, 8, 5, 2, 167, 168, 7, 126, 2, 2, 168, 173, 3, 2, 2, 2, 169, 170, 5, 10, 6, 2, 170, 171, 7, 126, 2, 2, 171, 173, 3, 2, 2, 2, 172, 128, 3, 2, 2, 2, 172, 129, 3, 2, 2, 2, 172, 134, 3, 2, 2, 2, 172, 137, 3, 2, 2, 2, 172, 139, 3, 2, 2, 2, 172, 141, 3, 2, 2, 2, 172, 143, 3, 2, 2, 2, 172, 145, 3, 2, 2, 2, 172, 146, 3, 2, 2, 2, 172, 147, 3, 2, 2, 2, 172, 150, 3, 2, 2, 2, 172, 151, 3, 2, 2, 2, 172, 154, 3, 2, 2, 2, 172, 155, 3, 2, 2, 2, 172, 156, 3, 2, 2, 2, 172, 157, 3, 2, 2, 2, 172, 160, 3, 2, 2, 2, 172, 163, 3, 2, 2, 2, 172, 166, 3, 2, 2, 2, 172, 169, 3, 2, 2, 2, 173, 7, 3, 2, 2, 2, 174, 175, 7, 7, 2, 2, 175, 176, 5, 44, 23, 2, 176, 9, 3, 2, 2, 2, 177, 178, 7, 6, 2, 2, 178, 179, 5, 44, 23, 2, 179, 11, 3, 2, 2, 2, 180, 181, 7, 28, 2, 2, 181, 186, 7, 99, 2, 2, 182, 183, 7, 131, 2, 2, 183, 185, 7, 99, 2, 2, 184, 182, 3, 2, 2, 2, 185, 188, 3, 2, 2, 2, 186, 184, 3, 2, 2, 2, 186, 187, 3, 2, 2, 2, 187, 13, 3, 2, 2, 2, 188, 186, 3, 2, 2, 2, 189, 190, 7, 8, 2, 2, 190, 195, 5, 16, 9, 2, 191, 192, 7, 131, 2, 2, 192, 194, 5, 16, 9, 2, 193, 191, 3, 2, 2, 2, 194, 197, 3, 2, 2, 2, 195, 193, 3, 2, 2, 2, 195, 196, 3, 2, 2, 2, 196, 15, 3, 2, 2, 2, 197, 195, 3, 2, 2, 2, 198, 199, 7, 88, 2, 2, 199, 200, 7, 99, 2, 2, 200, 201, 7, 127, 2, 2, 201, 202, 5, 110, 56, 2, 202, 17, 3, 2, 2, 2, 203, 204, 7, 90, 2, 2, 204, 205, 7, 43, 2, 2, 205, 206, 7, 137, 2, 2, 206, 19, 3, 2, 2, 2, 207, 208, 7, 31, 2, 2, 208, 209, 5, 6, 4, 2, 209, 210, 7, 34, 2, 2, 210, 211, 7, 119, 2, 2, 211, 212, 5, 44, 23, 2, 212, 213, 7, 120, 2, 2, 213, 21, 3, 2, 2, 2, 214, 216, 7, 129, 2, 2, 215, 217, 5, 4, 3, 2, 216, 215, 3, 2, 2, 2, 216, 217, 3, 2, 2, 2, 217, 218, 3, 2, 2, 2, 218, 219, 7, 130, 2, 2, 219, 23, 3, 2, 2, 2, 220, 221, 7, 29, 2, 2, 221, 222, 5, 44, 23, 2, 222, 223, 7, 26, 2, 2, 223, 226, 5, 44, 23, 2, 224, 225, 7, 87, 2, 2, 225, 227, 5, 44, 23, 2, 226, 224, 3, 2, 2, 2, 226, 227, 3, 2, 2, 2, 227, 234, 3, 2, 2, 2, 228, 229, 7, 30, 2, 2, 229, 230, 5, 44, 23, 2, 230, 231, 7, 26, 2, 2, 231, 232, 5, 44, 23, 2, 232, 234, 3, 2, 2, 2, 233, 220, 3, 2, 2, 2, 233, 228, 3, 2, 2, 2, 234, 25, 3, 2, 2, 2, 235, 236, 7, 21, 2, 2, 236, 237, 7, 119, 2, 2, 237, 238, 5, 44, 23, 2, 238, 243, 7, 120, 2, 2, 239, 240, 7, 9, 2, 2, 240, 242, 5, 44, 23, 2, 241, 239, 3, 2, 2, 2, 242, 245, 3, 2, 2, 2, 243, 241, 3, 2, 2, 2, 243, 244, 3, 2, 2, 2, 244, 255, 3, 2, 2, 2, 245, 243, 3, 2, 2, 2, 246, 247, 9, 2, 2, 2, 247, 252, 7, 99, 2, 2, 248, 249, 7, 131, 2, 2, 249, 251, 7, 99, 2, 2, 250, 248, 3, 2, 2, 2, 251, 254, 3, 2, 2, 2, 252, 250, 3, 2, 2, 2, 252, 253, 3, 2, 2, 2, 253, 256, 3, 2, 2, 2, 254, 252, 3, 2, 2, 2, 255, 246, 3, 2, 2, 2, 255, 256, 3, 2, 2, 2, 256, 257, 3, 2, 2, 2, 257, 258, 5, 6, 4, 2, 258, 27, 3, 2, 2, 2, 259, 260, 7, 22, 2, 2, 260, 261, 5, 6, 4, 2, 261, 262, 7, 21, 2, 2, 262, 263, 7, 119, 2, 2, 263, 264, 5, 44, 23, 2, 264, 265, 7, 120, 2, 2, 265, 29, 3, 2, 2, 2, 266, 267, 7, 19, 2, 2, 267, 268, 7, 119, 2, 2, 268, 269, 5, 44, 23, 2, 269, 270, 7, 120, 2, 2, 270, 273, 5, 6, 4, 2, 271, 272, 7, 20, 2, 2, 272, 274, 5, 6, 4, 2, 273, 271, 3, 2, 2, 2, 273, 274, 3, 2, 2, 2, 274, 31, 3, 2, 2, 2, 275, 276, 7, 23, 2, 2, 276, 277, 7, 119, 2, 2, 277, 278, 5, 44, 23, 2, 278, 279, 7, 126, 2, 2, 279, 280, 5, 44, 23, 2, 280, 281, 7, 126, 2, 2, 281, 282, 5, 44, 23, 2, 282, 283, 7, 120, 2, 2, 283, 284, 5, 6, 4, 2, 284, 33, 3, 2, 2, 2, 285, 286, 7, 24, 2, 2, 286, 287, 7, 99, 2, 2, 287, 288, 7, 26, 2, 2, 288, 289, 5, 44, 23, 2, 289, 290, 5, 6, 4, 2, 290, 35, 3, 2, 2, 2, 291, 292, 7, 99, 2, 2, 292, 301, 7, 119, 2, 2, 293, 298, 5, 42, 22, 2, 294, 295, 7, 131, 2, 2, 295, 297, 5, 42, 22, 2, 296, 294, 3, 2, 2, 2, 297, 300, 3, 2, 2, 2, 298, 296, 3, 2, 2, 2, 298, 299, 3, 2, 2, 2, 299, 302, 3, 2, 2, 2, 300, 298, 3, 2, 2, 2, 301, 293, 3, 2, 2, 2, 301, 302, 3, 2, 2, 2, 302, 303, 3, 2, 2, 2, 303, 306, 7, 120, 2, 2, 304, 305, 7, 127, 2, 2, 305, 307, 5, 110, 56, 2, 306, 304, 3, 2, 2, 2, 306, 307, 3, 2, 2, 2, 307, 317, 3, 2, 2, 2, 308, 309, 9, 2, 2, 2, 309, 314, 7, 99, 2, 2, 310, 311, 7, 131, 2, 2, 311, 313, 7, 99, 2, 2, 312, 310, 3, 2, 2, 2, 313, 316, 3, 2, 2, 2, 314, 312, 3, 2, 2, 2, 314, 315, 3, 2, 2, 2, 315, 318, 3, 2, 2, 2, 316, 314, 3, 2, 2, 2, 317, 308, 3, 2, 2, 2, 317, 318, 3, 2, 2, 2, 318, 323, 3, 2, 2, 2, 319, 320, 7, 10, 2, 2, 320, 322, 5, 38, 20, 2, 321, 319, 3, 2, 2, 2, 322, 325, 3, 2, 2, 2, 323, 321, 3, 2, 2, 2, 323, 324, 3, 2, 2, 2, 324, 330, 3, 2, 2, 2, 325, 323, 3, 2, 2, 2, 326, 327, 7, 11, 2, 2, 327, 329, 5, 40, 21, 2, 328, 326, 3, 2, 2, 2, 329, 332, 3, 2, 2, 2, 330, 328, 3, 2, 2, 2, 330, 331, 3, 2, 2, 2, 331, 333, 3, 2, 2, 2, 332, 330, 3, 2, 2, 2, 333, 334, 5, 22, 12, 2, 334, 37, 3, 2, 2, 2, 335, 336, 5, 44, 23, 2, 336, 39, 3, 2, 2, 2, 337, 338, 5, 44, 23, 2, 338, 41, 3, 2, 2, 2, 339, 341, 7, 27, 2, 2, 340, 339, 3, 2, 2, 2, 340, 341, 3, 2, 2, 2, 341, 342, 3, 2, 2, 2, 342, 345, 7, 99, 2, 2, 343, 344, 7, 127, 2, 2, 344, 346, 5, 110, 56, 2, 345, 343, 3, 2, 2, 2, 345, 346, 3, 2, 2, 2, 346, 43, 3, 2, 2, 2, 347, 348, 5, 46, 24, 2, 348, 349, 7, 13, 2, 2, 349, 350, 5, 44, 23, 2, 350, 389, 3, 2, 2, 2, 351, 352, 5, 46, 24, 2, 352, 353, 7, 14, 2, 2, 353, 354, 5, 44, 23, 2, 354, 389, 3, 2, 2, 2, 355, 356, 7, 15, 2, 2, 356, 357, 7, 99, 2, 2, 357, 358, 7, 127, 2, 2, 358, 365, 5, 110, 56, 2, 359, 360, 7, 131, 2, 2, 360, 361, 7, 99, 2, 2, 361, 362, 7, 127, 2, 2, 362, 364, 5, 110, 56, 2, 363, 359, 3, 2, 2, 2, 364, 367, 3, 2, 2, 2, 365, 363, 3, 2, 2, 2, 365, 366, 3, 2, 2, 2, 366, 368, 3, 2, 2, 2, 367, 365, 3, 2, 2, 2, 368, 369, 7, 17, 2, 2, 369, 370, 5, 44, 23, 2, 370, 389, 3, 2, 2, 2, 371, 372, 7, 16, 2, 2, 372, 373, 7, 99, 2, 2, 373, 374, 7, 127, 2, 2, 374, 381, 5, 110, 56, 2, 375, 376, 7, 131, 2, 2, 376, 377, 7, 99, 2, 2, 377, 378, 7, 127, 2, 2, 378, 380, 5, 110, 56, 2, 379, 375, 3, 2, 2, 2, 380, 383, 3, 2, 2, 2, 381, 379, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 384, 3, 2, 2, 2, 383, 381, 3, 2, 2, 2, 384, 385, 7, 17, 2, 2, 385, 386, 5, 44, 23, 2, 386, 389, 3, 2, 2, 2, 387, 389, 5, 46, 24, 2, 388, 347, 3, 2, 2, 2, 388, 351, 3, 2, 2, 2, 388, 355, 3, 2, 2, 2, 388, 371, 3, 2, 2, 2, 388, 387, 3, 2, 2, 2, 389, 45, 3, 2, 2, 2, 390, 391, 5, 76, 39, 2, 391, 392, 7, 113, 2, 2, 392, 393, 5, 44, 23, 2, 393, 396, 3, 2, 2, 2, 394, 396, 5, 48, 25, 2, 395, 390, 3, 2, 2, 2, 395, 394, 3, 2, 2, 2, 396, 47, 3, 2, 2, 2, 397, 403, 5, 50, 26, 2, 398, 399, 7, 136, 2, 2, 399, 400, 5, 44, 23, 2, 400, 401, 7, 127, 2, 2, 401, 402, 5, 44, 23, 2, 402, 404, 3, 2, 2, 2, 403, 398, 3, 2, 2, 2, 403, 404, 3, 2, 2, 2, 404, 49, 3, 2, 2, 2, 405, 410, 5, 52, 27, 2, 406, 407, 7, 123, 2, 2, 407, 409, 5, 52, 27, 2, 408, 406, 3, 2, 2, 2, 409, 412, 3, 2, 2, 2, 410, 408, 3, 2, 2, 2, 410, 411, 3, 2, 2, 2, 411, 51, 3, 2, 2, 2, 412, 410, 3, 2, 2, 2, 413, 418, 5, 54, 28, 2, 414, 415, 7, 124, 2, 2, 415, 417, 5, 54, 28, 2, 416, 414, 3, 2, 2, 2, 417, 420, 3, 2, 2, 2, 418, 416, 3, 2, 2, 2, 418, 419, 3, 2, 2, 2, 419, 53, 3, 2, 2, 2, 420, 418, 3, 2, 2, 2, 421, 426, 5, 56, 29, 2, 422, 423, 7, 25, 2, 2, 423, 425, 5, 56, 29, 2, 424, 422, 3, 2, 2, 2, 425, 428, 3, 2, 2, 2, 426, 424, 3, 2, 2, 2, 426, 427, 3, 2, 2, 2, 427, 55, 3, 2, 2, 2, 428, 426, 3, 2, 2, 2, 429, 434, 5, 58, 30, 2, 430, 431, 9, 3, 2, 2, 431, 433, 5, 58, 30, 2, 432, 430, 3, 2, 2, 2, 433, 436, 3, 2, 2, 2, 434, 432, 3, 2, 2, 2, 434, 435, 3, 2, 2, 2, 435, 57, 3, 2, 2, 2, 436, 434, 3, 2, 2, 2, 437, 442, 5, 60, 31, 2, 438, 439, 9, 4, 2, 2, 439, 441, 5, 60, 31, 2, 440, 438, 3, 2, 2, 2, 441, 444, 3, 2, 2, 2, 442, 440, 3, 2, 2, 2, 442, 443, 3, 2, 2, 2, 443, 59, 3, 2, 2, 2, 444, 442, 3, 2, 2, 2, 445, 450, 5, 62, 32, 2, 446, 447, 9, 5, 2, 2, 447, 449, 5, 62, 32, 2, 448, 446, 3, 2, 2, 2, 449, 452, 3, 2, 2, 2, 450, 448, 3, 2, 2, 2, 450, 451, 3, 2, 2, 2, 451, 61, 3, 2, 2, 2, 452, 450, 3, 2, 2, 2, 453, 458, 5, 64, 33, 2, 454, 455, 9, 6, 2, 2, 455, 457, 5, 64, 33, 2, 456, 454, 3, 2, 2, 2, 457, 460, 3, 2, 2, 2, 458, 456, 3, 2, 2, 2, 458, 459, 3, 2, 2, 2, 459, 63, 3, 2, 2, 2, 460, 458, 3, 2, 2, 2, 461, 466, 5, 66, 34, 2, 462, 463, 7, 102, 2, 2, 463, 465, 5, 66, 34, 2, 464, 462, 3, 2, 2, 2, 465, 468, 3, 2, 2, 2, 466, 464, 3, 2, 2, 2, 466, 467, 3, 2, 2, 2, 467, 65, 3, 2, 2, 2, 468, 466, 3, 2, 2, 2, 469, 474, 5, 68, 35, 2, 470, 471, 9, 7, 2, 2, 471, 473, 5, 68, 35, 2, 472, 470, 3, 2, 2, 2, 473, 476, 3, 2, 2, 2, 474, 472, 3, 2, 2, 2, 474, 475, 3, 2, 2, 2, 475, 67, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 477, 482, 5, 70, 36, 2, 478, 479, 9, 8, 2, 2, 479, 481, 5, 70, 36, 2, 480, 478, 3, 2, 2, 2, 481, 484, 3, 2, 2, 2, 482, 480, 3, 2, 2, 2, 482, 483, 3, 2, 2, 2, 483, 69, 3, 2, 2, 2, 484, 482, 3, 2, 2, 2, 485, 490, 5, 72, 37, 2, 486, 487, 9, 9, 2, 2, 487, 489, 5, 72, 37, 2, 488, 486, 3, 2, 2, 2, 489, 492, 3, 2, 2, 2, 490, 488, 3, 2, 2, 2, 490, 491, 3, 2, 2, 2, 491, 71, 3, 2, 2, 2, 492, 490, 3, 2, 2, 2, 493, 494, 9, 10, 2, 2, 494, 499, 5, 72, 37, 2, 495, 496, 9, 11, 2, 2, 496, 499, 5, 72, 37, 2, 497, 499, 5, 74, 38, 2, 498, 493, 3, 2, 2, 2, 498, 495, 3, 2, 2, 2, 498, 497, 3, 2, 2, 2, 499, 73, 3, 2, 2, 2, 500, 504, 5, 76, 39, 2, 501, 503, 9, 12, 2, 2, 502, 501, 3, 2, 2, 2, 503, 506, 3, 2, 2, 2, 504, 502, 3, 2, 2, 2, 504, 505, 3, 2, 2, 2, 505, 75, 3, 2, 2, 2, 506, 504, 3, 2, 2, 2, 507, 508, 8, 39, 1, 2, 508, 509, 5, 78, 40, 2, 509, 523, 3, 2, 2, 2, 510, 511, 12, 6, 2, 2, 511, 512, 7, 132, 2, 2, 512, 522, 5, 108, 55, 2, 513, 514, 12, 5, 2, 2, 514, 515, 7, 132, 2, 2, 515, 522, 7, 99, 2, 2, 516, 517, 12, 4, 2, 2, 517, 518, 7, 133, 2, 2, 518, 519, 5, 44, 23, 2, 519, 520, 7, 134, 2, 2, 520, 522, 3, 2, 2, 2, 521, 510, 3, 2, 2, 2, 521, 513, 3, 2, 2, 2, 521, 516, 3, 2, 2, 2, 522, 525, 3, 2, 2, 2, 523, 521, 3, 2, 2, 2, 523, 524, 3, 2, 2, 2, 524, 77, 3, 2, 2, 2, 525, 523, 3, 2, 2, 2, 526, 540, 7, 12, 2, 2, 527, 540, 5, 86, 44, 2, 528, 540, 5, 82, 42, 2, 529, 530, 7, 119, 2, 2, 530, 531, 5, 44, 23, 2, 531, 532, 7, 120, 2, 2, 532, 540, 3, 2, 2, 2, 533, 534, 7, 91, 2, 2, 534, 535, 5, 80, 41, 2, 535, 536, 7, 119, 2, 2, 536, 537, 5, 44, 23, 2, 537, 538, 7, 120, 2, 2, 538, 540, 3, 2, 2, 2, 539, 526, 3, 2, 2, 2, 539, 527, 3, 2, 2, 2, 539, 528, 3, 2, 2, 2, 539, 529, 3, 2, 2, 2, 539, 533, 3, 2, 2, 2, 540, 79, 3, 2, 2, 2, 541, 542, 7, 92, 2, 2, 542, 81, 3, 2, 2, 2, 543, 546, 5, 84, 43, 2, 544, 546, 5, 88, 45, 2, 545, 543, 3, 2, 2, 2, 545, 544, 3, 2, 2, 2, 546, 83, 3, 2, 2, 2, 547, 553, 7, 96, 2, 2, 548, 553, 7, 97, 2, 2, 549, 553, 7, 98, 2, 2, 550, 553, 7, 137, 2, 2, 551, 553, 7, 136, 2, 2, 552, 547, 3, 2, 2, 2, 552, 548, 3, 2, 2, 2, 552, 549, 3, 2, 2, 2, 552, 550, 3, 2, 2, 2, 552, 551, 3, 2, 2, 2, 553, 85, 3, 2, 2, 2, 554, 559, 5, 104, 53, 2, 555, 559, 7, 99, 2, 2, 556, 557, 7, 88, 2, 2, 557, 559, 7, 99, 2, 2, 558, 554, 3, 2, 2, 2, 558, 555, 3, 2, 2, 2, 558, 556, 3, 2, 2, 2, 559, 87, 3, 2, 2, 2, 560, 565, 5, 94, 48, 2, 561, 565, 5, 96, 49, 2, 562, 565, 5, 102, 52, 2, 563, 565, 5, 98, 50, 2, 564, 560, 3, 2, 2, 2, 564, 561, 3, 2, 2, 2, 564, 562, 3, 2, 2, 2, 564, 563, 3, 2, 2, 2, 565, 89, 3, 2, 2, 2, 566, 567, 5, 44, 23, 2, 567, 568, 7, 132, 2, 2, 568, 569, 7, 132, 2, 2, 569, 570, 5, 44, 23, 2, 570, 91, 3, 2, 2, 2, 571, 572, 7, 99, 2, 2, 572, 573, 7, 26, 2, 2, 573, 574, 5, 44, 23, 2, 574, 575, 7, 128, 2, 2, 575, 576, 5, 44, 23, 2, 576, 584, 3, 2, 2, 2, 577, 578, 5, 44, 23, 2, 578, 579, 7, 128, 2, 2, 579, 580, 7, 99, 2, 2, 580, 581, 7, 26, 2, 2, 581, 582, 5, 44, 23, 2, 582, 584, 3, 2, 2, 2, 583, 571, 3, 2, 2, 2, 583, 577, 3, 2, 2, 2, 584, 93, 3, 2, 2, 2, 585, 586, 7, 133, 2, 2, 586, 587, 5, 92, 47, 2, 587, 588, 7, 134, 2, 2, 588, 606, 3, 2, 2, 2, 589, 598, 7, 133, 2, 2, 590, 595, 5, 44, 23, 2, 591, 592, 7, 131, 2, 2, 592, 594, 5, 44, 23, 2, 593, 591, 3, 2, 2, 2, 594, 597, 3, 2, 2, 2, 595, 593, 3, 2, 2, 2, 595, 596, 3, 2, 2, 2, 596, 599, 3, 2, 2, 2, 597, 595, 3, 2, 2, 2, 598, 590, 3, 2, 2, 2, 598, 599, 3, 2, 2, 2, 599, 600, 3, 2, 2, 2, 600, 606, 7, 134, 2, 2, 601, 602, 7, 133, 2, 2, 602, 603, 5, 90, 46, 2, 603, 604, 7, 134, 2, 2, 604, 606, 3, 2, 2, 2, 605, 585, 3, 2, 2, 2, 605, 589, 3, 2, 2, 2, 605, 601, 3, 2, 2, 2, 606, 95, 3, 2, 2, 2, 607, 629, 7, 39, 2, 2, 608, 609, 7, 107, 2, 2, 609, 610, 5, 92, 47, 2, 610, 611, 7, 108, 2, 2, 611, 629, 3, 2, 2, 2, 612, 621, 7, 107, 2, 2, 613, 618, 5, 44, 23, 2, 614, 615, 7, 131, 2, 2, 615, 617, 5, 44, 23, 2, 616, 614, 3, 2, 2, 2, 617, 620, 3, 2, 2, 2, 618, 616, 3, 2, 2, 2, 618, 619, 3, 2, 2, 2, 619, 622, 3, 2, 2, 2, 620, 618, 3, 2, 2, 2, 621, 613, 3, 2, 2, 2, 621, 622, 3, 2, 2, 2, 622, 623, 3, 2, 2, 2, 623, 629, 7, 108, 2, 2, 624, 625, 7, 107, 2, 2, 625, 626, 5, 90, 46, 2, 626, 627, 7, 108, 2, 2, 627, 629, 3, 2, 2, 2, 628, 607, 3, 2, 2, 2, 628, 608, 3, 2, 2, 2, 628, 612, 3, 2, 2, 2, 628, 624, 3, 2, 2, 2, 629, 97, 3, 2, 2, 2, 630, 632, 7, 129, 2, 2, 631, 633, 5, 100, 51, 2, 632, 631, 3, 2, 2, 2, 633, 634, 3, 2, 2, 2, 634, 632, 3, 2, 2, 2, 634, 635, 3, 2, 2, 2, 635, 636, 3, 2, 2, 2, 636, 637, 7, 130, 2, 2, 637, 645, 3, 2, 2, 2, 638, 643, 7, 40, 2, 2, 639, 640, 7, 129, 2, 2, 640, 641, 7, 89, 2, 2, 641, 643, 7, 130, 2, 2, 642, 638, 3, 2, 2, 2, 642, 639, 3, 2, 2, 2, 643, 645, 3, 2, 2, 2, 644, 630, 3, 2, 2, 2, 644, 642, 3, 2, 2, 2, 645, 99, 3, 2, 2, 2, 646, 647, 7, 99, 2, 2, 647, 648, 7, 89, 2, 2, 648, 649, 5, 44, 23, 2, 649, 101, 3, 2, 2, 2, 650, 672, 7, 38, 2, 2, 651, 652, 7, 129, 2, 2, 652, 653, 5, 92, 47, 2, 653, 654, 7, 130, 2, 2, 654, 672, 3, 2, 2, 2, 655, 664, 7, 129, 2, 2, 656, 661, 5, 44, 23, 2, 657, 658, 7, 131, 2, 2, 658, 660, 5, 44, 23, 2, 659, 657, 3, 2, 2, 2, 660, 663, 3, 2, 2, 2, 661, 659, 3, 2, 2, 2, 661, 662, 3, 2, 2, 2, 662, 665, 3, 2, 2, 2, 663, 661, 3, 2, 2, 2, 664, 656, 3, 2, 2, 2, 664, 665, 3, 2, 2, 2, 665, 666, 3, 2, 2, 2, 666, 672, 7, 130, 2, 2, 667, 668, 7, 129, 2, 2, 668, 669, 5, 90, 46, 2, 669, 670, 7, 130, 2, 2, 670, 672, 3, 2, 2, 2, 671, 650, 3, 2, 2, 2, 671, 651, 3, 2, 2, 2, 671, 655, 3, 2, 2, 2, 671, 667, 3, 2, 2, 2, 672, 103, 3, 2, 2, 2, 673, 688, 5, 106, 54, 2, 674, 675, 7, 99, 2, 2, 675, 684, 7, 119, 2, 2, 676, 681, 5, 44, 23, 2, 677, 678, 7, 131, 2, 2, 678, 680, 5, 44, 23, 2, 679, 677, 3, 2, 2, 2, 680, 683, 3, 2, 2, 2, 681, 679, 3, 2, 2, 2, 681, 682, 3, 2, 2, 2, 682, 685, 3, 2, 2, 2, 683, 681, 3, 2, 2, 2, 684, 676, 3, 2, 2, 2, 684, 685, 3, 2, 2, 2, 685, 686, 3, 2, 2, 2, 686, 688, 7, 120, 2, 2, 687, 673, 3, 2, 2, 2, 687, 674, 3, 2, 2, 2, 688, 105, 3, 2, 2, 2, 689, 690, 5, 112, 57, 2, 690, 699, 7, 119, 2, 2, 691, 696, 5, 44, 23, 2, 692, 693, 7, 131, 2, 2, 693, 695, 5, 44, 23, 2, 694, 692, 3, 2, 2, 2, 695, 698, 3, 2, 2, 2, 696, 694, 3, 2, 2, 2, 696, 697, 3, 2, 2, 2, 697, 700, 3, 2, 2, 2, 698, 696, 3, 2, 2, 2, 699, 691, 3, 2, 2, 2, 699, 700, 3, 2, 2, 2, 700, 701, 3, 2, 2, 2, 701, 702, 7, 120, 2, 2, 702, 107, 3, 2, 2, 2, 703, 704, 5, 114, 58, 2, 704, 713, 7, 119, 2, 2, 705, 710, 5, 44, 23, 2, 706, 707, 7, 131, 2, 2, 707, 709, 5, 44, 23, 2, 708, 706, 3, 2, 2, 2, 709, 712, 3, 2, 2, 2, 710, 708, 3, 2, 2, 2, 710, 711, 3, 2, 2, 2, 711, 714, 3, 2, 2, 2, 712, 710, 3, 2, 2, 2, 713, 705, 3, 2, 2, 2, 713, 714, 3, 2, 2, 2, 714, 715, 3, 2, 2, 2, 715, 716, 7, 120, 2, 2, 716, 109, 3, 2, 2, 2, 717, 731, 7, 67, 2, 2, 718, 731, 7, 68, 2, 2, 719, 731, 7, 65, 2, 2, 720, 721, 7, 57, 2, 2, 721, 722, 7, 107, 2, 2, 722, 723, 5, 110, 56, 2, 723, 724, 7, 108, 2, 2, 724, 731, 3, 2, 2, 2, 725, 726, 7, 58, 2, 2, 726, 727, 7, 107, 2, 2, 727, 728, 5, 110, 56, 2, 728, 729, 7, 108, 2, 2, 729, 731, 3, 2, 2, 2, 730, 717, 3, 2, 2, 2, 730, 718, 3, 2, 2, 2, 730, 719, 3, 2, 2, 2, 730, 720, 3, 2, 2, 2, 730, 725, 3, 2, 2, 2, 731, 111, 3, 2, 2, 2, 732, 733, 9, 13, 2, 2, 733, 113, 3, 2, 2, 2, 734, 735, 9, 14, 2, 2, 735, 115, 3, 2, 2, 2, 736, 737, 7, 99, 2, 2, 737, 738, 7, 18, 2, 2, 738, 740, 5, 44, 23, 2, 739, 736, 3, 2, 2, 2, 740, 743, 3, 2, 2, 2, 741, 739, 3, 2, 2, 2, 741, 742, 3, 2, 2, 2, 742, 744, 3, 2, 2, 2, 743, 741, 3, 2, 2, 2, 744, 745, 7, 2, 2, 3, 745, 117, 3, 2, 2, 2, 71, 119, 126, 131, 172, 186, 195, 216, 226, 233, 243, 252, 255, 273, 298, 301, 306, 314, 317, 323, 330, 340, 345, 365, 381, 388, 395, 403, 410, 418, 426, 434, 442, 450, 458, 466, 474, 482, 490, 498, 504, 521, 523, 539, 545, 552, 558, 564, 583, 595, 598, 605, 618, 621, 628, 634, 642, 644, 661, 664, 671, 681, 684, 687, 696, 699, 710, 713, 730, 741] \ No newline at end of file +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 138, 772, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 3, 2, 5, 2, 124, 10, 2, 3, 2, 3, 2, 3, 3, 6, 3, 129, 10, 3, 13, 3, 14, 3, 130, 3, 4, 3, 4, 3, 4, 5, 4, 136, 10, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 5, 4, 177, 10, 4, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 7, 7, 189, 10, 7, 12, 7, 14, 7, 192, 11, 7, 3, 8, 3, 8, 3, 8, 3, 8, 7, 8, 198, 10, 8, 12, 8, 14, 8, 201, 11, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 5, 12, 221, 10, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 231, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 238, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 7, 14, 246, 10, 14, 12, 14, 14, 14, 249, 11, 14, 3, 14, 3, 14, 3, 14, 3, 14, 7, 14, 255, 10, 14, 12, 14, 14, 14, 258, 11, 14, 5, 14, 260, 10, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 278, 10, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 7, 19, 301, 10, 19, 12, 19, 14, 19, 304, 11, 19, 5, 19, 306, 10, 19, 3, 19, 3, 19, 3, 19, 5, 19, 311, 10, 19, 3, 19, 3, 19, 3, 19, 3, 19, 7, 19, 317, 10, 19, 12, 19, 14, 19, 320, 11, 19, 5, 19, 322, 10, 19, 3, 19, 3, 19, 7, 19, 326, 10, 19, 12, 19, 14, 19, 329, 11, 19, 3, 19, 3, 19, 7, 19, 333, 10, 19, 12, 19, 14, 19, 336, 11, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 21, 3, 21, 3, 22, 5, 22, 345, 10, 22, 3, 22, 3, 22, 3, 22, 5, 22, 350, 10, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 7, 23, 368, 10, 23, 12, 23, 14, 23, 371, 11, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 7, 23, 384, 10, 23, 12, 23, 14, 23, 387, 11, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 393, 10, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 400, 10, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 408, 10, 25, 3, 26, 3, 26, 3, 26, 7, 26, 413, 10, 26, 12, 26, 14, 26, 416, 11, 26, 3, 27, 3, 27, 3, 27, 7, 27, 421, 10, 27, 12, 27, 14, 27, 424, 11, 27, 3, 28, 3, 28, 3, 28, 7, 28, 429, 10, 28, 12, 28, 14, 28, 432, 11, 28, 3, 29, 3, 29, 3, 29, 7, 29, 437, 10, 29, 12, 29, 14, 29, 440, 11, 29, 3, 30, 3, 30, 3, 30, 7, 30, 445, 10, 30, 12, 30, 14, 30, 448, 11, 30, 3, 31, 3, 31, 3, 31, 7, 31, 453, 10, 31, 12, 31, 14, 31, 456, 11, 31, 3, 32, 3, 32, 3, 32, 7, 32, 461, 10, 32, 12, 32, 14, 32, 464, 11, 32, 3, 33, 3, 33, 3, 33, 7, 33, 469, 10, 33, 12, 33, 14, 33, 472, 11, 33, 3, 34, 3, 34, 3, 34, 7, 34, 477, 10, 34, 12, 34, 14, 34, 480, 11, 34, 3, 35, 3, 35, 3, 35, 7, 35, 485, 10, 35, 12, 35, 14, 35, 488, 11, 35, 3, 36, 3, 36, 3, 36, 7, 36, 493, 10, 36, 12, 36, 14, 36, 496, 11, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 5, 37, 503, 10, 37, 3, 38, 3, 38, 7, 38, 507, 10, 38, 12, 38, 14, 38, 510, 11, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 7, 39, 526, 10, 39, 12, 39, 14, 39, 529, 11, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 544, 10, 40, 3, 41, 3, 41, 3, 42, 3, 42, 5, 42, 550, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 557, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 563, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 570, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 5, 47, 589, 10, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 7, 48, 599, 10, 48, 12, 48, 14, 48, 602, 11, 48, 5, 48, 604, 10, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 5, 48, 611, 10, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 7, 49, 622, 10, 49, 12, 49, 14, 49, 625, 11, 49, 5, 49, 627, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 634, 10, 49, 3, 50, 3, 50, 6, 50, 638, 10, 50, 13, 50, 14, 50, 639, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 648, 10, 50, 5, 50, 650, 10, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 7, 52, 665, 10, 52, 12, 52, 14, 52, 668, 11, 52, 5, 52, 670, 10, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 5, 52, 677, 10, 52, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 683, 10, 53, 3, 53, 3, 53, 6, 53, 687, 10, 53, 13, 53, 14, 53, 688, 3, 53, 3, 53, 5, 53, 693, 10, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 7, 55, 705, 10, 55, 12, 55, 14, 55, 708, 11, 55, 5, 55, 710, 10, 55, 3, 55, 5, 55, 713, 10, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 7, 56, 720, 10, 56, 12, 56, 14, 56, 723, 11, 56, 5, 56, 725, 10, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 7, 57, 734, 10, 57, 12, 57, 14, 57, 737, 11, 57, 5, 57, 739, 10, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 756, 10, 58, 3, 59, 3, 59, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 7, 61, 765, 10, 61, 12, 61, 14, 61, 768, 11, 61, 3, 61, 3, 61, 3, 61, 2, 3, 76, 62, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 2, 15, 3, 2, 42, 43, 3, 2, 112, 113, 3, 2, 108, 111, 3, 2, 94, 96, 4, 2, 45, 45, 129, 129, 3, 2, 122, 123, 4, 2, 104, 105, 115, 116, 3, 2, 117, 119, 4, 2, 101, 102, 106, 107, 4, 2, 115, 117, 126, 126, 3, 2, 101, 102, 8, 2, 46, 57, 66, 66, 68, 68, 70, 70, 78, 78, 84, 87, 8, 2, 60, 60, 62, 62, 64, 65, 67, 67, 71, 77, 79, 83, 2, 824, 2, 123, 3, 2, 2, 2, 4, 128, 3, 2, 2, 2, 6, 176, 3, 2, 2, 2, 8, 178, 3, 2, 2, 2, 10, 181, 3, 2, 2, 2, 12, 184, 3, 2, 2, 2, 14, 193, 3, 2, 2, 2, 16, 202, 3, 2, 2, 2, 18, 207, 3, 2, 2, 2, 20, 211, 3, 2, 2, 2, 22, 218, 3, 2, 2, 2, 24, 237, 3, 2, 2, 2, 26, 239, 3, 2, 2, 2, 28, 263, 3, 2, 2, 2, 30, 270, 3, 2, 2, 2, 32, 279, 3, 2, 2, 2, 34, 289, 3, 2, 2, 2, 36, 295, 3, 2, 2, 2, 38, 339, 3, 2, 2, 2, 40, 341, 3, 2, 2, 2, 42, 344, 3, 2, 2, 2, 44, 392, 3, 2, 2, 2, 46, 399, 3, 2, 2, 2, 48, 401, 3, 2, 2, 2, 50, 409, 3, 2, 2, 2, 52, 417, 3, 2, 2, 2, 54, 425, 3, 2, 2, 2, 56, 433, 3, 2, 2, 2, 58, 441, 3, 2, 2, 2, 60, 449, 3, 2, 2, 2, 62, 457, 3, 2, 2, 2, 64, 465, 3, 2, 2, 2, 66, 473, 3, 2, 2, 2, 68, 481, 3, 2, 2, 2, 70, 489, 3, 2, 2, 2, 72, 502, 3, 2, 2, 2, 74, 504, 3, 2, 2, 2, 76, 511, 3, 2, 2, 2, 78, 543, 3, 2, 2, 2, 80, 545, 3, 2, 2, 2, 82, 549, 3, 2, 2, 2, 84, 556, 3, 2, 2, 2, 86, 562, 3, 2, 2, 2, 88, 569, 3, 2, 2, 2, 90, 571, 3, 2, 2, 2, 92, 588, 3, 2, 2, 2, 94, 610, 3, 2, 2, 2, 96, 633, 3, 2, 2, 2, 98, 649, 3, 2, 2, 2, 100, 651, 3, 2, 2, 2, 102, 676, 3, 2, 2, 2, 104, 692, 3, 2, 2, 2, 106, 694, 3, 2, 2, 2, 108, 712, 3, 2, 2, 2, 110, 714, 3, 2, 2, 2, 112, 728, 3, 2, 2, 2, 114, 755, 3, 2, 2, 2, 116, 757, 3, 2, 2, 2, 118, 759, 3, 2, 2, 2, 120, 766, 3, 2, 2, 2, 122, 124, 5, 4, 3, 2, 123, 122, 3, 2, 2, 2, 123, 124, 3, 2, 2, 2, 124, 125, 3, 2, 2, 2, 125, 126, 7, 2, 2, 3, 126, 3, 3, 2, 2, 2, 127, 129, 5, 6, 4, 2, 128, 127, 3, 2, 2, 2, 129, 130, 3, 2, 2, 2, 130, 128, 3, 2, 2, 2, 130, 131, 3, 2, 2, 2, 131, 5, 3, 2, 2, 2, 132, 177, 5, 36, 19, 2, 133, 135, 7, 32, 2, 2, 134, 136, 5, 44, 23, 2, 135, 134, 3, 2, 2, 2, 135, 136, 3, 2, 2, 2, 136, 137, 3, 2, 2, 2, 137, 177, 7, 127, 2, 2, 138, 139, 5, 24, 13, 2, 139, 140, 7, 127, 2, 2, 140, 177, 3, 2, 2, 2, 141, 142, 7, 33, 2, 2, 142, 177, 7, 127, 2, 2, 143, 144, 7, 35, 2, 2, 144, 177, 7, 127, 2, 2, 145, 146, 7, 36, 2, 2, 146, 177, 7, 127, 2, 2, 147, 148, 7, 37, 2, 2, 148, 177, 7, 127, 2, 2, 149, 177, 5, 22, 12, 2, 150, 177, 5, 18, 10, 2, 151, 152, 5, 20, 11, 2, 152, 153, 7, 127, 2, 2, 153, 177, 3, 2, 2, 2, 154, 177, 5, 26, 14, 2, 155, 156, 5, 28, 15, 2, 156, 157, 7, 127, 2, 2, 157, 177, 3, 2, 2, 2, 158, 177, 5, 30, 16, 2, 159, 177, 5, 32, 17, 2, 160, 177, 5, 34, 18, 2, 161, 162, 5, 44, 23, 2, 162, 163, 7, 127, 2, 2, 163, 177, 3, 2, 2, 2, 164, 165, 5, 14, 8, 2, 165, 166, 7, 127, 2, 2, 166, 177, 3, 2, 2, 2, 167, 168, 5, 12, 7, 2, 168, 169, 7, 127, 2, 2, 169, 177, 3, 2, 2, 2, 170, 171, 5, 8, 5, 2, 171, 172, 7, 127, 2, 2, 172, 177, 3, 2, 2, 2, 173, 174, 5, 10, 6, 2, 174, 175, 7, 127, 2, 2, 175, 177, 3, 2, 2, 2, 176, 132, 3, 2, 2, 2, 176, 133, 3, 2, 2, 2, 176, 138, 3, 2, 2, 2, 176, 141, 3, 2, 2, 2, 176, 143, 3, 2, 2, 2, 176, 145, 3, 2, 2, 2, 176, 147, 3, 2, 2, 2, 176, 149, 3, 2, 2, 2, 176, 150, 3, 2, 2, 2, 176, 151, 3, 2, 2, 2, 176, 154, 3, 2, 2, 2, 176, 155, 3, 2, 2, 2, 176, 158, 3, 2, 2, 2, 176, 159, 3, 2, 2, 2, 176, 160, 3, 2, 2, 2, 176, 161, 3, 2, 2, 2, 176, 164, 3, 2, 2, 2, 176, 167, 3, 2, 2, 2, 176, 170, 3, 2, 2, 2, 176, 173, 3, 2, 2, 2, 177, 7, 3, 2, 2, 2, 178, 179, 7, 7, 2, 2, 179, 180, 5, 44, 23, 2, 180, 9, 3, 2, 2, 2, 181, 182, 7, 6, 2, 2, 182, 183, 5, 44, 23, 2, 183, 11, 3, 2, 2, 2, 184, 185, 7, 28, 2, 2, 185, 190, 7, 100, 2, 2, 186, 187, 7, 132, 2, 2, 187, 189, 7, 100, 2, 2, 188, 186, 3, 2, 2, 2, 189, 192, 3, 2, 2, 2, 190, 188, 3, 2, 2, 2, 190, 191, 3, 2, 2, 2, 191, 13, 3, 2, 2, 2, 192, 190, 3, 2, 2, 2, 193, 194, 7, 8, 2, 2, 194, 199, 5, 16, 9, 2, 195, 196, 7, 132, 2, 2, 196, 198, 5, 16, 9, 2, 197, 195, 3, 2, 2, 2, 198, 201, 3, 2, 2, 2, 199, 197, 3, 2, 2, 2, 199, 200, 3, 2, 2, 2, 200, 15, 3, 2, 2, 2, 201, 199, 3, 2, 2, 2, 202, 203, 7, 89, 2, 2, 203, 204, 7, 100, 2, 2, 204, 205, 7, 128, 2, 2, 205, 206, 5, 114, 58, 2, 206, 17, 3, 2, 2, 2, 207, 208, 7, 91, 2, 2, 208, 209, 7, 44, 2, 2, 209, 210, 7, 138, 2, 2, 210, 19, 3, 2, 2, 2, 211, 212, 7, 31, 2, 2, 212, 213, 5, 6, 4, 2, 213, 214, 7, 34, 2, 2, 214, 215, 7, 120, 2, 2, 215, 216, 5, 44, 23, 2, 216, 217, 7, 121, 2, 2, 217, 21, 3, 2, 2, 2, 218, 220, 7, 130, 2, 2, 219, 221, 5, 4, 3, 2, 220, 219, 3, 2, 2, 2, 220, 221, 3, 2, 2, 2, 221, 222, 3, 2, 2, 2, 222, 223, 7, 131, 2, 2, 223, 23, 3, 2, 2, 2, 224, 225, 7, 29, 2, 2, 225, 226, 5, 44, 23, 2, 226, 227, 7, 26, 2, 2, 227, 230, 5, 44, 23, 2, 228, 229, 7, 88, 2, 2, 229, 231, 5, 44, 23, 2, 230, 228, 3, 2, 2, 2, 230, 231, 3, 2, 2, 2, 231, 238, 3, 2, 2, 2, 232, 233, 7, 30, 2, 2, 233, 234, 5, 44, 23, 2, 234, 235, 7, 26, 2, 2, 235, 236, 5, 44, 23, 2, 236, 238, 3, 2, 2, 2, 237, 224, 3, 2, 2, 2, 237, 232, 3, 2, 2, 2, 238, 25, 3, 2, 2, 2, 239, 240, 7, 21, 2, 2, 240, 241, 7, 120, 2, 2, 241, 242, 5, 44, 23, 2, 242, 247, 7, 121, 2, 2, 243, 244, 7, 9, 2, 2, 244, 246, 5, 44, 23, 2, 245, 243, 3, 2, 2, 2, 246, 249, 3, 2, 2, 2, 247, 245, 3, 2, 2, 2, 247, 248, 3, 2, 2, 2, 248, 259, 3, 2, 2, 2, 249, 247, 3, 2, 2, 2, 250, 251, 9, 2, 2, 2, 251, 256, 7, 100, 2, 2, 252, 253, 7, 132, 2, 2, 253, 255, 7, 100, 2, 2, 254, 252, 3, 2, 2, 2, 255, 258, 3, 2, 2, 2, 256, 254, 3, 2, 2, 2, 256, 257, 3, 2, 2, 2, 257, 260, 3, 2, 2, 2, 258, 256, 3, 2, 2, 2, 259, 250, 3, 2, 2, 2, 259, 260, 3, 2, 2, 2, 260, 261, 3, 2, 2, 2, 261, 262, 5, 6, 4, 2, 262, 27, 3, 2, 2, 2, 263, 264, 7, 22, 2, 2, 264, 265, 5, 6, 4, 2, 265, 266, 7, 21, 2, 2, 266, 267, 7, 120, 2, 2, 267, 268, 5, 44, 23, 2, 268, 269, 7, 121, 2, 2, 269, 29, 3, 2, 2, 2, 270, 271, 7, 19, 2, 2, 271, 272, 7, 120, 2, 2, 272, 273, 5, 44, 23, 2, 273, 274, 7, 121, 2, 2, 274, 277, 5, 6, 4, 2, 275, 276, 7, 20, 2, 2, 276, 278, 5, 6, 4, 2, 277, 275, 3, 2, 2, 2, 277, 278, 3, 2, 2, 2, 278, 31, 3, 2, 2, 2, 279, 280, 7, 23, 2, 2, 280, 281, 7, 120, 2, 2, 281, 282, 5, 44, 23, 2, 282, 283, 7, 127, 2, 2, 283, 284, 5, 44, 23, 2, 284, 285, 7, 127, 2, 2, 285, 286, 5, 44, 23, 2, 286, 287, 7, 121, 2, 2, 287, 288, 5, 6, 4, 2, 288, 33, 3, 2, 2, 2, 289, 290, 7, 24, 2, 2, 290, 291, 7, 100, 2, 2, 291, 292, 7, 26, 2, 2, 292, 293, 5, 44, 23, 2, 293, 294, 5, 6, 4, 2, 294, 35, 3, 2, 2, 2, 295, 296, 7, 100, 2, 2, 296, 305, 7, 120, 2, 2, 297, 302, 5, 42, 22, 2, 298, 299, 7, 132, 2, 2, 299, 301, 5, 42, 22, 2, 300, 298, 3, 2, 2, 2, 301, 304, 3, 2, 2, 2, 302, 300, 3, 2, 2, 2, 302, 303, 3, 2, 2, 2, 303, 306, 3, 2, 2, 2, 304, 302, 3, 2, 2, 2, 305, 297, 3, 2, 2, 2, 305, 306, 3, 2, 2, 2, 306, 307, 3, 2, 2, 2, 307, 310, 7, 121, 2, 2, 308, 309, 7, 128, 2, 2, 309, 311, 5, 114, 58, 2, 310, 308, 3, 2, 2, 2, 310, 311, 3, 2, 2, 2, 311, 321, 3, 2, 2, 2, 312, 313, 9, 2, 2, 2, 313, 318, 7, 100, 2, 2, 314, 315, 7, 132, 2, 2, 315, 317, 7, 100, 2, 2, 316, 314, 3, 2, 2, 2, 317, 320, 3, 2, 2, 2, 318, 316, 3, 2, 2, 2, 318, 319, 3, 2, 2, 2, 319, 322, 3, 2, 2, 2, 320, 318, 3, 2, 2, 2, 321, 312, 3, 2, 2, 2, 321, 322, 3, 2, 2, 2, 322, 327, 3, 2, 2, 2, 323, 324, 7, 10, 2, 2, 324, 326, 5, 38, 20, 2, 325, 323, 3, 2, 2, 2, 326, 329, 3, 2, 2, 2, 327, 325, 3, 2, 2, 2, 327, 328, 3, 2, 2, 2, 328, 334, 3, 2, 2, 2, 329, 327, 3, 2, 2, 2, 330, 331, 7, 11, 2, 2, 331, 333, 5, 40, 21, 2, 332, 330, 3, 2, 2, 2, 333, 336, 3, 2, 2, 2, 334, 332, 3, 2, 2, 2, 334, 335, 3, 2, 2, 2, 335, 337, 3, 2, 2, 2, 336, 334, 3, 2, 2, 2, 337, 338, 5, 22, 12, 2, 338, 37, 3, 2, 2, 2, 339, 340, 5, 44, 23, 2, 340, 39, 3, 2, 2, 2, 341, 342, 5, 44, 23, 2, 342, 41, 3, 2, 2, 2, 343, 345, 7, 27, 2, 2, 344, 343, 3, 2, 2, 2, 344, 345, 3, 2, 2, 2, 345, 346, 3, 2, 2, 2, 346, 349, 7, 100, 2, 2, 347, 348, 7, 128, 2, 2, 348, 350, 5, 114, 58, 2, 349, 347, 3, 2, 2, 2, 349, 350, 3, 2, 2, 2, 350, 43, 3, 2, 2, 2, 351, 352, 5, 46, 24, 2, 352, 353, 7, 13, 2, 2, 353, 354, 5, 44, 23, 2, 354, 393, 3, 2, 2, 2, 355, 356, 5, 46, 24, 2, 356, 357, 7, 14, 2, 2, 357, 358, 5, 44, 23, 2, 358, 393, 3, 2, 2, 2, 359, 360, 7, 15, 2, 2, 360, 361, 7, 100, 2, 2, 361, 362, 7, 128, 2, 2, 362, 369, 5, 114, 58, 2, 363, 364, 7, 132, 2, 2, 364, 365, 7, 100, 2, 2, 365, 366, 7, 128, 2, 2, 366, 368, 5, 114, 58, 2, 367, 363, 3, 2, 2, 2, 368, 371, 3, 2, 2, 2, 369, 367, 3, 2, 2, 2, 369, 370, 3, 2, 2, 2, 370, 372, 3, 2, 2, 2, 371, 369, 3, 2, 2, 2, 372, 373, 7, 17, 2, 2, 373, 374, 5, 44, 23, 2, 374, 393, 3, 2, 2, 2, 375, 376, 7, 16, 2, 2, 376, 377, 7, 100, 2, 2, 377, 378, 7, 128, 2, 2, 378, 385, 5, 114, 58, 2, 379, 380, 7, 132, 2, 2, 380, 381, 7, 100, 2, 2, 381, 382, 7, 128, 2, 2, 382, 384, 5, 114, 58, 2, 383, 379, 3, 2, 2, 2, 384, 387, 3, 2, 2, 2, 385, 383, 3, 2, 2, 2, 385, 386, 3, 2, 2, 2, 386, 388, 3, 2, 2, 2, 387, 385, 3, 2, 2, 2, 388, 389, 7, 17, 2, 2, 389, 390, 5, 44, 23, 2, 390, 393, 3, 2, 2, 2, 391, 393, 5, 46, 24, 2, 392, 351, 3, 2, 2, 2, 392, 355, 3, 2, 2, 2, 392, 359, 3, 2, 2, 2, 392, 375, 3, 2, 2, 2, 392, 391, 3, 2, 2, 2, 393, 45, 3, 2, 2, 2, 394, 395, 5, 76, 39, 2, 395, 396, 7, 114, 2, 2, 396, 397, 5, 44, 23, 2, 397, 400, 3, 2, 2, 2, 398, 400, 5, 48, 25, 2, 399, 394, 3, 2, 2, 2, 399, 398, 3, 2, 2, 2, 400, 47, 3, 2, 2, 2, 401, 407, 5, 50, 26, 2, 402, 403, 7, 137, 2, 2, 403, 404, 5, 44, 23, 2, 404, 405, 7, 128, 2, 2, 405, 406, 5, 44, 23, 2, 406, 408, 3, 2, 2, 2, 407, 402, 3, 2, 2, 2, 407, 408, 3, 2, 2, 2, 408, 49, 3, 2, 2, 2, 409, 414, 5, 52, 27, 2, 410, 411, 7, 124, 2, 2, 411, 413, 5, 52, 27, 2, 412, 410, 3, 2, 2, 2, 413, 416, 3, 2, 2, 2, 414, 412, 3, 2, 2, 2, 414, 415, 3, 2, 2, 2, 415, 51, 3, 2, 2, 2, 416, 414, 3, 2, 2, 2, 417, 422, 5, 54, 28, 2, 418, 419, 7, 125, 2, 2, 419, 421, 5, 54, 28, 2, 420, 418, 3, 2, 2, 2, 421, 424, 3, 2, 2, 2, 422, 420, 3, 2, 2, 2, 422, 423, 3, 2, 2, 2, 423, 53, 3, 2, 2, 2, 424, 422, 3, 2, 2, 2, 425, 430, 5, 56, 29, 2, 426, 427, 7, 25, 2, 2, 427, 429, 5, 56, 29, 2, 428, 426, 3, 2, 2, 2, 429, 432, 3, 2, 2, 2, 430, 428, 3, 2, 2, 2, 430, 431, 3, 2, 2, 2, 431, 55, 3, 2, 2, 2, 432, 430, 3, 2, 2, 2, 433, 438, 5, 58, 30, 2, 434, 435, 9, 3, 2, 2, 435, 437, 5, 58, 30, 2, 436, 434, 3, 2, 2, 2, 437, 440, 3, 2, 2, 2, 438, 436, 3, 2, 2, 2, 438, 439, 3, 2, 2, 2, 439, 57, 3, 2, 2, 2, 440, 438, 3, 2, 2, 2, 441, 446, 5, 60, 31, 2, 442, 443, 9, 4, 2, 2, 443, 445, 5, 60, 31, 2, 444, 442, 3, 2, 2, 2, 445, 448, 3, 2, 2, 2, 446, 444, 3, 2, 2, 2, 446, 447, 3, 2, 2, 2, 447, 59, 3, 2, 2, 2, 448, 446, 3, 2, 2, 2, 449, 454, 5, 62, 32, 2, 450, 451, 9, 5, 2, 2, 451, 453, 5, 62, 32, 2, 452, 450, 3, 2, 2, 2, 453, 456, 3, 2, 2, 2, 454, 452, 3, 2, 2, 2, 454, 455, 3, 2, 2, 2, 455, 61, 3, 2, 2, 2, 456, 454, 3, 2, 2, 2, 457, 462, 5, 64, 33, 2, 458, 459, 9, 6, 2, 2, 459, 461, 5, 64, 33, 2, 460, 458, 3, 2, 2, 2, 461, 464, 3, 2, 2, 2, 462, 460, 3, 2, 2, 2, 462, 463, 3, 2, 2, 2, 463, 63, 3, 2, 2, 2, 464, 462, 3, 2, 2, 2, 465, 470, 5, 66, 34, 2, 466, 467, 7, 103, 2, 2, 467, 469, 5, 66, 34, 2, 468, 466, 3, 2, 2, 2, 469, 472, 3, 2, 2, 2, 470, 468, 3, 2, 2, 2, 470, 471, 3, 2, 2, 2, 471, 65, 3, 2, 2, 2, 472, 470, 3, 2, 2, 2, 473, 478, 5, 68, 35, 2, 474, 475, 9, 7, 2, 2, 475, 477, 5, 68, 35, 2, 476, 474, 3, 2, 2, 2, 477, 480, 3, 2, 2, 2, 478, 476, 3, 2, 2, 2, 478, 479, 3, 2, 2, 2, 479, 67, 3, 2, 2, 2, 480, 478, 3, 2, 2, 2, 481, 486, 5, 70, 36, 2, 482, 483, 9, 8, 2, 2, 483, 485, 5, 70, 36, 2, 484, 482, 3, 2, 2, 2, 485, 488, 3, 2, 2, 2, 486, 484, 3, 2, 2, 2, 486, 487, 3, 2, 2, 2, 487, 69, 3, 2, 2, 2, 488, 486, 3, 2, 2, 2, 489, 494, 5, 72, 37, 2, 490, 491, 9, 9, 2, 2, 491, 493, 5, 72, 37, 2, 492, 490, 3, 2, 2, 2, 493, 496, 3, 2, 2, 2, 494, 492, 3, 2, 2, 2, 494, 495, 3, 2, 2, 2, 495, 71, 3, 2, 2, 2, 496, 494, 3, 2, 2, 2, 497, 498, 9, 10, 2, 2, 498, 503, 5, 72, 37, 2, 499, 500, 9, 11, 2, 2, 500, 503, 5, 72, 37, 2, 501, 503, 5, 74, 38, 2, 502, 497, 3, 2, 2, 2, 502, 499, 3, 2, 2, 2, 502, 501, 3, 2, 2, 2, 503, 73, 3, 2, 2, 2, 504, 508, 5, 76, 39, 2, 505, 507, 9, 12, 2, 2, 506, 505, 3, 2, 2, 2, 507, 510, 3, 2, 2, 2, 508, 506, 3, 2, 2, 2, 508, 509, 3, 2, 2, 2, 509, 75, 3, 2, 2, 2, 510, 508, 3, 2, 2, 2, 511, 512, 8, 39, 1, 2, 512, 513, 5, 78, 40, 2, 513, 527, 3, 2, 2, 2, 514, 515, 12, 6, 2, 2, 515, 516, 7, 133, 2, 2, 516, 526, 5, 112, 57, 2, 517, 518, 12, 5, 2, 2, 518, 519, 7, 133, 2, 2, 519, 526, 7, 100, 2, 2, 520, 521, 12, 4, 2, 2, 521, 522, 7, 134, 2, 2, 522, 523, 5, 44, 23, 2, 523, 524, 7, 135, 2, 2, 524, 526, 3, 2, 2, 2, 525, 514, 3, 2, 2, 2, 525, 517, 3, 2, 2, 2, 525, 520, 3, 2, 2, 2, 526, 529, 3, 2, 2, 2, 527, 525, 3, 2, 2, 2, 527, 528, 3, 2, 2, 2, 528, 77, 3, 2, 2, 2, 529, 527, 3, 2, 2, 2, 530, 544, 7, 12, 2, 2, 531, 544, 5, 86, 44, 2, 532, 544, 5, 82, 42, 2, 533, 534, 7, 120, 2, 2, 534, 535, 5, 44, 23, 2, 535, 536, 7, 121, 2, 2, 536, 544, 3, 2, 2, 2, 537, 538, 7, 92, 2, 2, 538, 539, 5, 80, 41, 2, 539, 540, 7, 120, 2, 2, 540, 541, 5, 44, 23, 2, 541, 542, 7, 121, 2, 2, 542, 544, 3, 2, 2, 2, 543, 530, 3, 2, 2, 2, 543, 531, 3, 2, 2, 2, 543, 532, 3, 2, 2, 2, 543, 533, 3, 2, 2, 2, 543, 537, 3, 2, 2, 2, 544, 79, 3, 2, 2, 2, 545, 546, 7, 93, 2, 2, 546, 81, 3, 2, 2, 2, 547, 550, 5, 84, 43, 2, 548, 550, 5, 88, 45, 2, 549, 547, 3, 2, 2, 2, 549, 548, 3, 2, 2, 2, 550, 83, 3, 2, 2, 2, 551, 557, 7, 97, 2, 2, 552, 557, 7, 98, 2, 2, 553, 557, 7, 99, 2, 2, 554, 557, 7, 138, 2, 2, 555, 557, 7, 137, 2, 2, 556, 551, 3, 2, 2, 2, 556, 552, 3, 2, 2, 2, 556, 553, 3, 2, 2, 2, 556, 554, 3, 2, 2, 2, 556, 555, 3, 2, 2, 2, 557, 85, 3, 2, 2, 2, 558, 563, 5, 108, 55, 2, 559, 563, 7, 100, 2, 2, 560, 561, 7, 89, 2, 2, 561, 563, 7, 100, 2, 2, 562, 558, 3, 2, 2, 2, 562, 559, 3, 2, 2, 2, 562, 560, 3, 2, 2, 2, 563, 87, 3, 2, 2, 2, 564, 570, 5, 94, 48, 2, 565, 570, 5, 96, 49, 2, 566, 570, 5, 102, 52, 2, 567, 570, 5, 98, 50, 2, 568, 570, 5, 104, 53, 2, 569, 564, 3, 2, 2, 2, 569, 565, 3, 2, 2, 2, 569, 566, 3, 2, 2, 2, 569, 567, 3, 2, 2, 2, 569, 568, 3, 2, 2, 2, 570, 89, 3, 2, 2, 2, 571, 572, 5, 44, 23, 2, 572, 573, 7, 133, 2, 2, 573, 574, 7, 133, 2, 2, 574, 575, 5, 44, 23, 2, 575, 91, 3, 2, 2, 2, 576, 577, 7, 100, 2, 2, 577, 578, 7, 26, 2, 2, 578, 579, 5, 44, 23, 2, 579, 580, 7, 129, 2, 2, 580, 581, 5, 44, 23, 2, 581, 589, 3, 2, 2, 2, 582, 583, 5, 44, 23, 2, 583, 584, 7, 129, 2, 2, 584, 585, 7, 100, 2, 2, 585, 586, 7, 26, 2, 2, 586, 587, 5, 44, 23, 2, 587, 589, 3, 2, 2, 2, 588, 576, 3, 2, 2, 2, 588, 582, 3, 2, 2, 2, 589, 93, 3, 2, 2, 2, 590, 591, 7, 134, 2, 2, 591, 592, 5, 92, 47, 2, 592, 593, 7, 135, 2, 2, 593, 611, 3, 2, 2, 2, 594, 603, 7, 134, 2, 2, 595, 600, 5, 44, 23, 2, 596, 597, 7, 132, 2, 2, 597, 599, 5, 44, 23, 2, 598, 596, 3, 2, 2, 2, 599, 602, 3, 2, 2, 2, 600, 598, 3, 2, 2, 2, 600, 601, 3, 2, 2, 2, 601, 604, 3, 2, 2, 2, 602, 600, 3, 2, 2, 2, 603, 595, 3, 2, 2, 2, 603, 604, 3, 2, 2, 2, 604, 605, 3, 2, 2, 2, 605, 611, 7, 135, 2, 2, 606, 607, 7, 134, 2, 2, 607, 608, 5, 90, 46, 2, 608, 609, 7, 135, 2, 2, 609, 611, 3, 2, 2, 2, 610, 590, 3, 2, 2, 2, 610, 594, 3, 2, 2, 2, 610, 606, 3, 2, 2, 2, 611, 95, 3, 2, 2, 2, 612, 634, 7, 40, 2, 2, 613, 614, 7, 108, 2, 2, 614, 615, 5, 92, 47, 2, 615, 616, 7, 109, 2, 2, 616, 634, 3, 2, 2, 2, 617, 626, 7, 108, 2, 2, 618, 623, 5, 44, 23, 2, 619, 620, 7, 132, 2, 2, 620, 622, 5, 44, 23, 2, 621, 619, 3, 2, 2, 2, 622, 625, 3, 2, 2, 2, 623, 621, 3, 2, 2, 2, 623, 624, 3, 2, 2, 2, 624, 627, 3, 2, 2, 2, 625, 623, 3, 2, 2, 2, 626, 618, 3, 2, 2, 2, 626, 627, 3, 2, 2, 2, 627, 628, 3, 2, 2, 2, 628, 634, 7, 109, 2, 2, 629, 630, 7, 108, 2, 2, 630, 631, 5, 90, 46, 2, 631, 632, 7, 109, 2, 2, 632, 634, 3, 2, 2, 2, 633, 612, 3, 2, 2, 2, 633, 613, 3, 2, 2, 2, 633, 617, 3, 2, 2, 2, 633, 629, 3, 2, 2, 2, 634, 97, 3, 2, 2, 2, 635, 637, 7, 130, 2, 2, 636, 638, 5, 100, 51, 2, 637, 636, 3, 2, 2, 2, 638, 639, 3, 2, 2, 2, 639, 637, 3, 2, 2, 2, 639, 640, 3, 2, 2, 2, 640, 641, 3, 2, 2, 2, 641, 642, 7, 131, 2, 2, 642, 650, 3, 2, 2, 2, 643, 648, 7, 41, 2, 2, 644, 645, 7, 130, 2, 2, 645, 646, 7, 90, 2, 2, 646, 648, 7, 131, 2, 2, 647, 643, 3, 2, 2, 2, 647, 644, 3, 2, 2, 2, 648, 650, 3, 2, 2, 2, 649, 635, 3, 2, 2, 2, 649, 647, 3, 2, 2, 2, 650, 99, 3, 2, 2, 2, 651, 652, 7, 100, 2, 2, 652, 653, 7, 90, 2, 2, 653, 654, 5, 44, 23, 2, 654, 101, 3, 2, 2, 2, 655, 677, 7, 39, 2, 2, 656, 657, 7, 130, 2, 2, 657, 658, 5, 92, 47, 2, 658, 659, 7, 131, 2, 2, 659, 677, 3, 2, 2, 2, 660, 669, 7, 130, 2, 2, 661, 666, 5, 44, 23, 2, 662, 663, 7, 132, 2, 2, 663, 665, 5, 44, 23, 2, 664, 662, 3, 2, 2, 2, 665, 668, 3, 2, 2, 2, 666, 664, 3, 2, 2, 2, 666, 667, 3, 2, 2, 2, 667, 670, 3, 2, 2, 2, 668, 666, 3, 2, 2, 2, 669, 661, 3, 2, 2, 2, 669, 670, 3, 2, 2, 2, 670, 671, 3, 2, 2, 2, 671, 677, 7, 131, 2, 2, 672, 673, 7, 130, 2, 2, 673, 674, 5, 90, 46, 2, 674, 675, 7, 131, 2, 2, 675, 677, 3, 2, 2, 2, 676, 655, 3, 2, 2, 2, 676, 656, 3, 2, 2, 2, 676, 660, 3, 2, 2, 2, 676, 672, 3, 2, 2, 2, 677, 103, 3, 2, 2, 2, 678, 683, 7, 38, 2, 2, 679, 680, 7, 130, 2, 2, 680, 681, 7, 18, 2, 2, 681, 683, 7, 131, 2, 2, 682, 678, 3, 2, 2, 2, 682, 679, 3, 2, 2, 2, 683, 693, 3, 2, 2, 2, 684, 686, 7, 130, 2, 2, 685, 687, 5, 106, 54, 2, 686, 685, 3, 2, 2, 2, 687, 688, 3, 2, 2, 2, 688, 686, 3, 2, 2, 2, 688, 689, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 691, 7, 131, 2, 2, 691, 693, 3, 2, 2, 2, 692, 682, 3, 2, 2, 2, 692, 684, 3, 2, 2, 2, 693, 105, 3, 2, 2, 2, 694, 695, 5, 44, 23, 2, 695, 696, 7, 18, 2, 2, 696, 697, 5, 44, 23, 2, 697, 107, 3, 2, 2, 2, 698, 713, 5, 110, 56, 2, 699, 700, 7, 100, 2, 2, 700, 709, 7, 120, 2, 2, 701, 706, 5, 44, 23, 2, 702, 703, 7, 132, 2, 2, 703, 705, 5, 44, 23, 2, 704, 702, 3, 2, 2, 2, 705, 708, 3, 2, 2, 2, 706, 704, 3, 2, 2, 2, 706, 707, 3, 2, 2, 2, 707, 710, 3, 2, 2, 2, 708, 706, 3, 2, 2, 2, 709, 701, 3, 2, 2, 2, 709, 710, 3, 2, 2, 2, 710, 711, 3, 2, 2, 2, 711, 713, 7, 121, 2, 2, 712, 698, 3, 2, 2, 2, 712, 699, 3, 2, 2, 2, 713, 109, 3, 2, 2, 2, 714, 715, 5, 116, 59, 2, 715, 724, 7, 120, 2, 2, 716, 721, 5, 44, 23, 2, 717, 718, 7, 132, 2, 2, 718, 720, 5, 44, 23, 2, 719, 717, 3, 2, 2, 2, 720, 723, 3, 2, 2, 2, 721, 719, 3, 2, 2, 2, 721, 722, 3, 2, 2, 2, 722, 725, 3, 2, 2, 2, 723, 721, 3, 2, 2, 2, 724, 716, 3, 2, 2, 2, 724, 725, 3, 2, 2, 2, 725, 726, 3, 2, 2, 2, 726, 727, 7, 121, 2, 2, 727, 111, 3, 2, 2, 2, 728, 729, 5, 118, 60, 2, 729, 738, 7, 120, 2, 2, 730, 735, 5, 44, 23, 2, 731, 732, 7, 132, 2, 2, 732, 734, 5, 44, 23, 2, 733, 731, 3, 2, 2, 2, 734, 737, 3, 2, 2, 2, 735, 733, 3, 2, 2, 2, 735, 736, 3, 2, 2, 2, 736, 739, 3, 2, 2, 2, 737, 735, 3, 2, 2, 2, 738, 730, 3, 2, 2, 2, 738, 739, 3, 2, 2, 2, 739, 740, 3, 2, 2, 2, 740, 741, 7, 121, 2, 2, 741, 113, 3, 2, 2, 2, 742, 756, 7, 68, 2, 2, 743, 756, 7, 69, 2, 2, 744, 756, 7, 66, 2, 2, 745, 746, 7, 58, 2, 2, 746, 747, 7, 108, 2, 2, 747, 748, 5, 114, 58, 2, 748, 749, 7, 109, 2, 2, 749, 756, 3, 2, 2, 2, 750, 751, 7, 59, 2, 2, 751, 752, 7, 108, 2, 2, 752, 753, 5, 114, 58, 2, 753, 754, 7, 109, 2, 2, 754, 756, 3, 2, 2, 2, 755, 742, 3, 2, 2, 2, 755, 743, 3, 2, 2, 2, 755, 744, 3, 2, 2, 2, 755, 745, 3, 2, 2, 2, 755, 750, 3, 2, 2, 2, 756, 115, 3, 2, 2, 2, 757, 758, 9, 13, 2, 2, 758, 117, 3, 2, 2, 2, 759, 760, 9, 14, 2, 2, 760, 119, 3, 2, 2, 2, 761, 762, 7, 100, 2, 2, 762, 763, 7, 18, 2, 2, 763, 765, 5, 44, 23, 2, 764, 761, 3, 2, 2, 2, 765, 768, 3, 2, 2, 2, 766, 764, 3, 2, 2, 2, 766, 767, 3, 2, 2, 2, 767, 769, 3, 2, 2, 2, 768, 766, 3, 2, 2, 2, 769, 770, 7, 2, 2, 3, 770, 121, 3, 2, 2, 2, 74, 123, 130, 135, 176, 190, 199, 220, 230, 237, 247, 256, 259, 277, 302, 305, 310, 318, 321, 327, 334, 344, 349, 369, 385, 392, 399, 407, 414, 422, 430, 438, 446, 454, 462, 470, 478, 486, 494, 502, 508, 525, 527, 543, 549, 556, 562, 569, 588, 600, 603, 610, 623, 626, 633, 639, 647, 649, 666, 669, 676, 682, 688, 692, 706, 709, 712, 721, 724, 735, 738, 755, 766] \ No newline at end of file diff --git a/src/main/java/grammar/alk.tokens b/src/main/java/grammar/alk.tokens index cbdc4f5a..67a292e6 100644 --- a/src/main/java/grammar/alk.tokens +++ b/src/main/java/grammar/alk.tokens @@ -33,106 +33,107 @@ UNTIL=32 FAILURE=33 CONTINUE=34 BREAK=35 -EMPTYSET=36 -EMPTYLIST=37 -EMPTYSTRUCTURE=38 -MODIFIES=39 -USES=40 -INCLDUE=41 -XOR=42 -ABS=43 -ACOS=44 -ASIN=45 -ATAN=46 -COS=47 -LOG=48 -PI=49 -POW=50 -SIN=51 -SQRT=52 -TAN=53 -LEN=54 -ARRAY=55 -SET=56 -AT=57 -BELONGSTO=58 -DELETE=59 -EMPTY=60 -END=61 -FIRST=62 -FLOAT=63 -INSERT=64 -INTEGER=65 -BOOLEAN=66 -PRINT=67 -POPBACK=68 -POPFRONT=69 -PUSHBACK=70 -PUSHFRONT=71 -REMOVE=72 -REMOVEALLEQTO=73 -REMOVEAT=74 -SINGLETONSET=75 -SIZE=76 -SPLIT=77 -TOPBACK=78 -TOPFRONT=79 -UPDATE=80 -UNIFORMNAT=81 -FLIP=82 -UNIFORMFLOAT=83 -UNIFORMPERM=84 -SOTHAT=85 -SYM=86 -ARROW=87 -NUMSIGN=88 -ANNO=89 -COUNT=90 -UNION=91 -INTERSECT=92 -SUBTRACT=93 -INT=94 -DOUBLE=95 -BOOL=96 -ID=97 -PLUSPLUS=98 -MINUSMINUS=99 -BITWISE_AND=100 -PLUSMOD=101 -MINUSMOD=102 -PLUSPLUSMOD=103 -MINUSMINUSMOD=104 -LOWER=105 -GREATER=106 -LOWEREQ=107 -GREATEREQ=108 -ISEQUAL=109 -NOTEQUAL=110 -ASSIGNMENT_OPERATOR=111 -MINUS=112 -PLUS=113 -MUL=114 -DIV=115 -MOD=116 -LPAR=117 -RPAR=118 -LEFTSHIFT=119 -RIGHTSHIFT=120 -OR=121 -AND=122 -NOT=123 -SEMICOLON=124 -DPOINT=125 -VBAR=126 -LCB=127 -RCB=128 -COMMA=129 -POINT=130 -LBRA=131 -RBRA=132 -QUOTE=133 -QUESTION=134 -STRING=135 +EMPTYMAP=36 +EMPTYSET=37 +EMPTYLIST=38 +EMPTYSTRUCTURE=39 +MODIFIES=40 +USES=41 +INCLDUE=42 +XOR=43 +ABS=44 +ACOS=45 +ASIN=46 +ATAN=47 +COS=48 +LOG=49 +PI=50 +POW=51 +SIN=52 +SQRT=53 +TAN=54 +LEN=55 +ARRAY=56 +SET=57 +AT=58 +BELONGSTO=59 +DELETE=60 +EMPTY=61 +END=62 +FIRST=63 +FLOAT=64 +INSERT=65 +INTEGER=66 +BOOLEAN=67 +PRINT=68 +POPBACK=69 +POPFRONT=70 +PUSHBACK=71 +PUSHFRONT=72 +REMOVE=73 +REMOVEALLEQTO=74 +REMOVEAT=75 +SINGLETONSET=76 +SIZE=77 +SPLIT=78 +TOPBACK=79 +TOPFRONT=80 +UPDATE=81 +UNIFORMNAT=82 +FLIP=83 +UNIFORMFLOAT=84 +UNIFORMPERM=85 +SOTHAT=86 +SYM=87 +ARROW=88 +NUMSIGN=89 +ANNO=90 +COUNT=91 +UNION=92 +INTERSECT=93 +SUBTRACT=94 +INT=95 +DOUBLE=96 +BOOL=97 +ID=98 +PLUSPLUS=99 +MINUSMINUS=100 +BITWISE_AND=101 +PLUSMOD=102 +MINUSMOD=103 +PLUSPLUSMOD=104 +MINUSMINUSMOD=105 +LOWER=106 +GREATER=107 +LOWEREQ=108 +GREATEREQ=109 +ISEQUAL=110 +NOTEQUAL=111 +ASSIGNMENT_OPERATOR=112 +MINUS=113 +PLUS=114 +MUL=115 +DIV=116 +MOD=117 +LPAR=118 +RPAR=119 +LEFTSHIFT=120 +RIGHTSHIFT=121 +OR=122 +AND=123 +NOT=124 +SEMICOLON=125 +DPOINT=126 +VBAR=127 +LCB=128 +RCB=129 +COMMA=130 +POINT=131 +LBRA=132 +RBRA=133 +QUOTE=134 +QUESTION=135 +STRING=136 'assert'=4 'assume'=5 'symbolic'=6 @@ -165,97 +166,98 @@ STRING=135 'failure'=33 'continue'=34 'break'=35 -'emptySet'=36 -'emptyList'=37 -'emptyStructure'=38 -'modifies'=39 -'uses'=40 -'include'=41 -'xor'=42 -'abs'=43 -'acos'=44 -'asin'=45 -'atan'=46 -'cos'=47 -'log'=48 -'pi'=49 -'pow'=50 -'sin'=51 -'sqrt'=52 -'tan'=53 -'len'=54 -'array'=55 -'set'=56 -'at'=57 -'belongsTo'=58 -'delete'=59 -'empty'=60 -'end'=61 -'first'=62 -'float'=63 -'insert'=64 -'int'=65 -'boolean'=66 -'print'=67 -'popBack'=68 -'popFront'=69 -'pushBack'=70 -'pushFront'=71 -'remove'=72 -'removeAllEqTo'=73 -'removeAt'=74 -'singletonSet'=75 -'size'=76 -'split'=77 -'topBack'=78 -'topFront'=79 -'update'=80 -'uniformNat'=81 -'flip'=82 -'uniformFloat'=83 -'uniformPerm'=84 -'s.t.'=85 -'$'=86 -'->'=87 -'#'=88 -'@'=89 -'Count'=90 -'U'=91 -'^'=92 -'\\'=93 -'++'=98 -'--'=99 -'&'=100 -'+%'=101 -'-%'=102 -'++%'=103 -'--%'=104 -'<'=105 -'>'=106 -'<='=107 -'>='=108 -'=='=109 -'!='=110 -'-'=112 -'+'=113 -'*'=114 -'/'=115 -'%'=116 -'('=117 -')'=118 -'<<'=119 -'>>'=120 -'||'=121 -'&&'=122 -'!'=123 -';'=124 -':'=125 -'|'=126 -'{'=127 -'}'=128 -','=129 -'.'=130 -'['=131 -']'=132 -'"'=133 -'?'=134 +'emptyMap'=36 +'emptySet'=37 +'emptyList'=38 +'emptyStructure'=39 +'modifies'=40 +'uses'=41 +'include'=42 +'xor'=43 +'abs'=44 +'acos'=45 +'asin'=46 +'atan'=47 +'cos'=48 +'log'=49 +'pi'=50 +'pow'=51 +'sin'=52 +'sqrt'=53 +'tan'=54 +'len'=55 +'array'=56 +'set'=57 +'at'=58 +'belongsTo'=59 +'delete'=60 +'empty'=61 +'end'=62 +'first'=63 +'float'=64 +'insert'=65 +'int'=66 +'boolean'=67 +'print'=68 +'popBack'=69 +'popFront'=70 +'pushBack'=71 +'pushFront'=72 +'remove'=73 +'removeAllEqTo'=74 +'removeAt'=75 +'singletonSet'=76 +'size'=77 +'split'=78 +'topBack'=79 +'topFront'=80 +'update'=81 +'uniformNat'=82 +'flip'=83 +'uniformFloat'=84 +'uniformPerm'=85 +'s.t.'=86 +'$'=87 +'->'=88 +'#'=89 +'@'=90 +'Count'=91 +'U'=92 +'^'=93 +'\\'=94 +'++'=99 +'--'=100 +'&'=101 +'+%'=102 +'-%'=103 +'++%'=104 +'--%'=105 +'<'=106 +'>'=107 +'<='=108 +'>='=109 +'=='=110 +'!='=111 +'-'=113 +'+'=114 +'*'=115 +'/'=116 +'%'=117 +'('=118 +')'=119 +'<<'=120 +'>>'=121 +'||'=122 +'&&'=123 +'!'=124 +';'=125 +':'=126 +'|'=127 +'{'=128 +'}'=129 +','=130 +'.'=131 +'['=132 +']'=133 +'"'=134 +'?'=135 diff --git a/src/main/java/grammar/alkBaseVisitor.java b/src/main/java/grammar/alkBaseVisitor.java index a9211544..54b3b340 100644 --- a/src/main/java/grammar/alkBaseVisitor.java +++ b/src/main/java/grammar/alkBaseVisitor.java @@ -622,6 +622,13 @@ public class alkBaseVisitor extends AbstractParseTreeVisitor implements al * {@link #visitChildren} on {@code ctx}.

*/ @Override public T visitStructureValue(alkParser.StructureValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMappingValue(alkParser.MappingValueContext ctx) { return visitChildren(ctx); } /** * {@inheritDoc} * @@ -741,6 +748,27 @@ public class alkBaseVisitor extends AbstractParseTreeVisitor implements al * {@link #visitChildren} on {@code ctx}.

*/ @Override public T visitSetWithInterval(alkParser.SetWithIntervalContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEmptyMapping(alkParser.EmptyMappingContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMappingWithComponents(alkParser.MappingWithComponentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMappingComponentDefinition(alkParser.MappingComponentDefinitionContext ctx) { return visitChildren(ctx); } /** * {@inheritDoc} * diff --git a/src/main/java/grammar/alkLexer.interp b/src/main/java/grammar/alkLexer.interp index 910eb32a..9273192c 100644 --- a/src/main/java/grammar/alkLexer.interp +++ b/src/main/java/grammar/alkLexer.interp @@ -35,6 +35,7 @@ null 'failure' 'continue' 'break' +'emptyMap' 'emptySet' 'emptyList' 'emptyStructure' @@ -173,6 +174,7 @@ UNTIL FAILURE CONTINUE BREAK +EMPTYMAP EMPTYSET EMPTYLIST EMPTYSTRUCTURE @@ -313,6 +315,7 @@ UNTIL FAILURE CONTINUE BREAK +EMPTYMAP EMPTYSET EMPTYLIST EMPTYSTRUCTURE @@ -422,4 +425,4 @@ mode names: DEFAULT_MODE atn: -[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 137, 1041, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 3, 2, 6, 2, 281, 10, 2, 13, 2, 14, 2, 282, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 7, 3, 291, 10, 3, 12, 3, 14, 3, 294, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 7, 4, 305, 10, 4, 12, 4, 14, 4, 308, 11, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 96, 3, 96, 3, 97, 3, 97, 3, 98, 6, 98, 888, 10, 98, 13, 98, 14, 98, 889, 3, 99, 6, 99, 893, 10, 99, 13, 99, 14, 99, 894, 3, 99, 3, 99, 6, 99, 899, 10, 99, 13, 99, 14, 99, 900, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 912, 10, 100, 3, 101, 3, 101, 3, 101, 7, 101, 917, 10, 101, 12, 101, 14, 101, 920, 11, 101, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 981, 10, 115, 3, 116, 3, 116, 3, 117, 3, 117, 3, 118, 3, 118, 3, 119, 3, 119, 3, 120, 3, 120, 3, 121, 3, 121, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 128, 3, 128, 3, 129, 3, 129, 3, 130, 3, 130, 3, 131, 3, 131, 3, 132, 3, 132, 3, 133, 3, 133, 3, 134, 3, 134, 3, 135, 3, 135, 3, 136, 3, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 7, 139, 1035, 10, 139, 12, 139, 14, 139, 1038, 11, 139, 3, 139, 3, 139, 3, 292, 2, 140, 3, 3, 5, 4, 7, 5, 9, 2, 11, 2, 13, 2, 15, 6, 17, 7, 19, 8, 21, 9, 23, 10, 25, 11, 27, 12, 29, 13, 31, 14, 33, 15, 35, 16, 37, 17, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 30, 65, 31, 67, 32, 69, 33, 71, 34, 73, 35, 75, 36, 77, 37, 79, 38, 81, 39, 83, 40, 85, 41, 87, 42, 89, 43, 91, 44, 93, 45, 95, 46, 97, 47, 99, 48, 101, 49, 103, 50, 105, 51, 107, 52, 109, 53, 111, 54, 113, 55, 115, 56, 117, 57, 119, 58, 121, 59, 123, 60, 125, 61, 127, 62, 129, 63, 131, 64, 133, 65, 135, 66, 137, 67, 139, 68, 141, 69, 143, 70, 145, 71, 147, 72, 149, 73, 151, 74, 153, 75, 155, 76, 157, 77, 159, 78, 161, 79, 163, 80, 165, 81, 167, 82, 169, 83, 171, 84, 173, 85, 175, 86, 177, 87, 179, 88, 181, 89, 183, 90, 185, 91, 187, 92, 189, 93, 191, 94, 193, 95, 195, 96, 197, 97, 199, 98, 201, 99, 203, 100, 205, 101, 207, 102, 209, 103, 211, 104, 213, 105, 215, 106, 217, 107, 219, 108, 221, 109, 223, 110, 225, 111, 227, 112, 229, 113, 231, 114, 233, 115, 235, 116, 237, 117, 239, 118, 241, 119, 243, 120, 245, 121, 247, 122, 249, 123, 251, 124, 253, 125, 255, 126, 257, 127, 259, 128, 261, 129, 263, 130, 265, 131, 267, 132, 269, 133, 271, 134, 273, 135, 275, 136, 277, 137, 3, 2, 8, 5, 2, 11, 12, 15, 15, 34, 34, 4, 2, 12, 12, 15, 15, 5, 2, 67, 92, 97, 97, 99, 124, 3, 2, 50, 59, 3, 2, 51, 59, 5, 2, 12, 12, 15, 15, 36, 36, 2, 1056, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 2, 197, 3, 2, 2, 2, 2, 199, 3, 2, 2, 2, 2, 201, 3, 2, 2, 2, 2, 203, 3, 2, 2, 2, 2, 205, 3, 2, 2, 2, 2, 207, 3, 2, 2, 2, 2, 209, 3, 2, 2, 2, 2, 211, 3, 2, 2, 2, 2, 213, 3, 2, 2, 2, 2, 215, 3, 2, 2, 2, 2, 217, 3, 2, 2, 2, 2, 219, 3, 2, 2, 2, 2, 221, 3, 2, 2, 2, 2, 223, 3, 2, 2, 2, 2, 225, 3, 2, 2, 2, 2, 227, 3, 2, 2, 2, 2, 229, 3, 2, 2, 2, 2, 231, 3, 2, 2, 2, 2, 233, 3, 2, 2, 2, 2, 235, 3, 2, 2, 2, 2, 237, 3, 2, 2, 2, 2, 239, 3, 2, 2, 2, 2, 241, 3, 2, 2, 2, 2, 243, 3, 2, 2, 2, 2, 245, 3, 2, 2, 2, 2, 247, 3, 2, 2, 2, 2, 249, 3, 2, 2, 2, 2, 251, 3, 2, 2, 2, 2, 253, 3, 2, 2, 2, 2, 255, 3, 2, 2, 2, 2, 257, 3, 2, 2, 2, 2, 259, 3, 2, 2, 2, 2, 261, 3, 2, 2, 2, 2, 263, 3, 2, 2, 2, 2, 265, 3, 2, 2, 2, 2, 267, 3, 2, 2, 2, 2, 269, 3, 2, 2, 2, 2, 271, 3, 2, 2, 2, 2, 273, 3, 2, 2, 2, 2, 275, 3, 2, 2, 2, 2, 277, 3, 2, 2, 2, 3, 280, 3, 2, 2, 2, 5, 286, 3, 2, 2, 2, 7, 300, 3, 2, 2, 2, 9, 311, 3, 2, 2, 2, 11, 313, 3, 2, 2, 2, 13, 315, 3, 2, 2, 2, 15, 317, 3, 2, 2, 2, 17, 324, 3, 2, 2, 2, 19, 331, 3, 2, 2, 2, 21, 340, 3, 2, 2, 2, 23, 350, 3, 2, 2, 2, 25, 359, 3, 2, 2, 2, 27, 367, 3, 2, 2, 2, 29, 374, 3, 2, 2, 2, 31, 378, 3, 2, 2, 2, 33, 383, 3, 2, 2, 2, 35, 390, 3, 2, 2, 2, 37, 397, 3, 2, 2, 2, 39, 400, 3, 2, 2, 2, 41, 404, 3, 2, 2, 2, 43, 407, 3, 2, 2, 2, 45, 412, 3, 2, 2, 2, 47, 418, 3, 2, 2, 2, 49, 421, 3, 2, 2, 2, 51, 425, 3, 2, 2, 2, 53, 433, 3, 2, 2, 2, 55, 436, 3, 2, 2, 2, 57, 441, 3, 2, 2, 2, 59, 445, 3, 2, 2, 2, 61, 451, 3, 2, 2, 2, 63, 458, 3, 2, 2, 2, 65, 466, 3, 2, 2, 2, 67, 473, 3, 2, 2, 2, 69, 480, 3, 2, 2, 2, 71, 488, 3, 2, 2, 2, 73, 494, 3, 2, 2, 2, 75, 502, 3, 2, 2, 2, 77, 511, 3, 2, 2, 2, 79, 517, 3, 2, 2, 2, 81, 526, 3, 2, 2, 2, 83, 536, 3, 2, 2, 2, 85, 551, 3, 2, 2, 2, 87, 560, 3, 2, 2, 2, 89, 565, 3, 2, 2, 2, 91, 573, 3, 2, 2, 2, 93, 577, 3, 2, 2, 2, 95, 581, 3, 2, 2, 2, 97, 586, 3, 2, 2, 2, 99, 591, 3, 2, 2, 2, 101, 596, 3, 2, 2, 2, 103, 600, 3, 2, 2, 2, 105, 604, 3, 2, 2, 2, 107, 607, 3, 2, 2, 2, 109, 611, 3, 2, 2, 2, 111, 615, 3, 2, 2, 2, 113, 620, 3, 2, 2, 2, 115, 624, 3, 2, 2, 2, 117, 628, 3, 2, 2, 2, 119, 634, 3, 2, 2, 2, 121, 638, 3, 2, 2, 2, 123, 641, 3, 2, 2, 2, 125, 651, 3, 2, 2, 2, 127, 658, 3, 2, 2, 2, 129, 664, 3, 2, 2, 2, 131, 668, 3, 2, 2, 2, 133, 674, 3, 2, 2, 2, 135, 680, 3, 2, 2, 2, 137, 687, 3, 2, 2, 2, 139, 691, 3, 2, 2, 2, 141, 699, 3, 2, 2, 2, 143, 705, 3, 2, 2, 2, 145, 713, 3, 2, 2, 2, 147, 722, 3, 2, 2, 2, 149, 731, 3, 2, 2, 2, 151, 741, 3, 2, 2, 2, 153, 748, 3, 2, 2, 2, 155, 762, 3, 2, 2, 2, 157, 771, 3, 2, 2, 2, 159, 784, 3, 2, 2, 2, 161, 789, 3, 2, 2, 2, 163, 795, 3, 2, 2, 2, 165, 803, 3, 2, 2, 2, 167, 812, 3, 2, 2, 2, 169, 819, 3, 2, 2, 2, 171, 830, 3, 2, 2, 2, 173, 835, 3, 2, 2, 2, 175, 848, 3, 2, 2, 2, 177, 860, 3, 2, 2, 2, 179, 865, 3, 2, 2, 2, 181, 867, 3, 2, 2, 2, 183, 870, 3, 2, 2, 2, 185, 872, 3, 2, 2, 2, 187, 874, 3, 2, 2, 2, 189, 880, 3, 2, 2, 2, 191, 882, 3, 2, 2, 2, 193, 884, 3, 2, 2, 2, 195, 887, 3, 2, 2, 2, 197, 892, 3, 2, 2, 2, 199, 911, 3, 2, 2, 2, 201, 913, 3, 2, 2, 2, 203, 921, 3, 2, 2, 2, 205, 924, 3, 2, 2, 2, 207, 927, 3, 2, 2, 2, 209, 929, 3, 2, 2, 2, 211, 932, 3, 2, 2, 2, 213, 935, 3, 2, 2, 2, 215, 939, 3, 2, 2, 2, 217, 943, 3, 2, 2, 2, 219, 945, 3, 2, 2, 2, 221, 947, 3, 2, 2, 2, 223, 950, 3, 2, 2, 2, 225, 953, 3, 2, 2, 2, 227, 956, 3, 2, 2, 2, 229, 980, 3, 2, 2, 2, 231, 982, 3, 2, 2, 2, 233, 984, 3, 2, 2, 2, 235, 986, 3, 2, 2, 2, 237, 988, 3, 2, 2, 2, 239, 990, 3, 2, 2, 2, 241, 992, 3, 2, 2, 2, 243, 994, 3, 2, 2, 2, 245, 996, 3, 2, 2, 2, 247, 999, 3, 2, 2, 2, 249, 1002, 3, 2, 2, 2, 251, 1005, 3, 2, 2, 2, 253, 1008, 3, 2, 2, 2, 255, 1010, 3, 2, 2, 2, 257, 1012, 3, 2, 2, 2, 259, 1014, 3, 2, 2, 2, 261, 1016, 3, 2, 2, 2, 263, 1018, 3, 2, 2, 2, 265, 1020, 3, 2, 2, 2, 267, 1022, 3, 2, 2, 2, 269, 1024, 3, 2, 2, 2, 271, 1026, 3, 2, 2, 2, 273, 1028, 3, 2, 2, 2, 275, 1030, 3, 2, 2, 2, 277, 1032, 3, 2, 2, 2, 279, 281, 9, 2, 2, 2, 280, 279, 3, 2, 2, 2, 281, 282, 3, 2, 2, 2, 282, 280, 3, 2, 2, 2, 282, 283, 3, 2, 2, 2, 283, 284, 3, 2, 2, 2, 284, 285, 8, 2, 2, 2, 285, 4, 3, 2, 2, 2, 286, 287, 7, 49, 2, 2, 287, 288, 7, 44, 2, 2, 288, 292, 3, 2, 2, 2, 289, 291, 11, 2, 2, 2, 290, 289, 3, 2, 2, 2, 291, 294, 3, 2, 2, 2, 292, 293, 3, 2, 2, 2, 292, 290, 3, 2, 2, 2, 293, 295, 3, 2, 2, 2, 294, 292, 3, 2, 2, 2, 295, 296, 7, 44, 2, 2, 296, 297, 7, 49, 2, 2, 297, 298, 3, 2, 2, 2, 298, 299, 8, 3, 2, 2, 299, 6, 3, 2, 2, 2, 300, 301, 7, 49, 2, 2, 301, 302, 7, 49, 2, 2, 302, 306, 3, 2, 2, 2, 303, 305, 10, 3, 2, 2, 304, 303, 3, 2, 2, 2, 305, 308, 3, 2, 2, 2, 306, 304, 3, 2, 2, 2, 306, 307, 3, 2, 2, 2, 307, 309, 3, 2, 2, 2, 308, 306, 3, 2, 2, 2, 309, 310, 8, 4, 2, 2, 310, 8, 3, 2, 2, 2, 311, 312, 9, 4, 2, 2, 312, 10, 3, 2, 2, 2, 313, 314, 9, 5, 2, 2, 314, 12, 3, 2, 2, 2, 315, 316, 9, 6, 2, 2, 316, 14, 3, 2, 2, 2, 317, 318, 7, 99, 2, 2, 318, 319, 7, 117, 2, 2, 319, 320, 7, 117, 2, 2, 320, 321, 7, 103, 2, 2, 321, 322, 7, 116, 2, 2, 322, 323, 7, 118, 2, 2, 323, 16, 3, 2, 2, 2, 324, 325, 7, 99, 2, 2, 325, 326, 7, 117, 2, 2, 326, 327, 7, 117, 2, 2, 327, 328, 7, 119, 2, 2, 328, 329, 7, 111, 2, 2, 329, 330, 7, 103, 2, 2, 330, 18, 3, 2, 2, 2, 331, 332, 7, 117, 2, 2, 332, 333, 7, 123, 2, 2, 333, 334, 7, 111, 2, 2, 334, 335, 7, 100, 2, 2, 335, 336, 7, 113, 2, 2, 336, 337, 7, 110, 2, 2, 337, 338, 7, 107, 2, 2, 338, 339, 7, 101, 2, 2, 339, 20, 3, 2, 2, 2, 340, 341, 7, 107, 2, 2, 341, 342, 7, 112, 2, 2, 342, 343, 7, 120, 2, 2, 343, 344, 7, 99, 2, 2, 344, 345, 7, 116, 2, 2, 345, 346, 7, 107, 2, 2, 346, 347, 7, 99, 2, 2, 347, 348, 7, 112, 2, 2, 348, 349, 7, 118, 2, 2, 349, 22, 3, 2, 2, 2, 350, 351, 7, 116, 2, 2, 351, 352, 7, 103, 2, 2, 352, 353, 7, 115, 2, 2, 353, 354, 7, 119, 2, 2, 354, 355, 7, 107, 2, 2, 355, 356, 7, 116, 2, 2, 356, 357, 7, 103, 2, 2, 357, 358, 7, 117, 2, 2, 358, 24, 3, 2, 2, 2, 359, 360, 7, 103, 2, 2, 360, 361, 7, 112, 2, 2, 361, 362, 7, 117, 2, 2, 362, 363, 7, 119, 2, 2, 363, 364, 7, 116, 2, 2, 364, 365, 7, 103, 2, 2, 365, 366, 7, 117, 2, 2, 366, 26, 3, 2, 2, 2, 367, 368, 7, 116, 2, 2, 368, 369, 7, 103, 2, 2, 369, 370, 7, 117, 2, 2, 370, 371, 7, 119, 2, 2, 371, 372, 7, 110, 2, 2, 372, 373, 7, 118, 2, 2, 373, 28, 3, 2, 2, 2, 374, 375, 7, 63, 2, 2, 375, 376, 7, 63, 2, 2, 376, 377, 7, 64, 2, 2, 377, 30, 3, 2, 2, 2, 378, 379, 7, 62, 2, 2, 379, 380, 7, 63, 2, 2, 380, 381, 7, 63, 2, 2, 381, 382, 7, 64, 2, 2, 382, 32, 3, 2, 2, 2, 383, 384, 7, 104, 2, 2, 384, 385, 7, 113, 2, 2, 385, 386, 7, 116, 2, 2, 386, 387, 7, 99, 2, 2, 387, 388, 7, 110, 2, 2, 388, 389, 7, 110, 2, 2, 389, 34, 3, 2, 2, 2, 390, 391, 7, 103, 2, 2, 391, 392, 7, 122, 2, 2, 392, 393, 7, 107, 2, 2, 393, 394, 7, 117, 2, 2, 394, 395, 7, 118, 2, 2, 395, 396, 7, 117, 2, 2, 396, 36, 3, 2, 2, 2, 397, 398, 7, 60, 2, 2, 398, 399, 7, 60, 2, 2, 399, 38, 3, 2, 2, 2, 400, 401, 7, 126, 2, 2, 401, 402, 7, 47, 2, 2, 402, 403, 7, 64, 2, 2, 403, 40, 3, 2, 2, 2, 404, 405, 7, 107, 2, 2, 405, 406, 7, 104, 2, 2, 406, 42, 3, 2, 2, 2, 407, 408, 7, 103, 2, 2, 408, 409, 7, 110, 2, 2, 409, 410, 7, 117, 2, 2, 410, 411, 7, 103, 2, 2, 411, 44, 3, 2, 2, 2, 412, 413, 7, 121, 2, 2, 413, 414, 7, 106, 2, 2, 414, 415, 7, 107, 2, 2, 415, 416, 7, 110, 2, 2, 416, 417, 7, 103, 2, 2, 417, 46, 3, 2, 2, 2, 418, 419, 7, 102, 2, 2, 419, 420, 7, 113, 2, 2, 420, 48, 3, 2, 2, 2, 421, 422, 7, 104, 2, 2, 422, 423, 7, 113, 2, 2, 423, 424, 7, 116, 2, 2, 424, 50, 3, 2, 2, 2, 425, 426, 7, 104, 2, 2, 426, 427, 7, 113, 2, 2, 427, 428, 7, 116, 2, 2, 428, 429, 7, 103, 2, 2, 429, 430, 7, 99, 2, 2, 430, 431, 7, 101, 2, 2, 431, 432, 7, 106, 2, 2, 432, 52, 3, 2, 2, 2, 433, 434, 7, 107, 2, 2, 434, 435, 7, 112, 2, 2, 435, 54, 3, 2, 2, 2, 436, 437, 7, 104, 2, 2, 437, 438, 7, 116, 2, 2, 438, 439, 7, 113, 2, 2, 439, 440, 7, 111, 2, 2, 440, 56, 3, 2, 2, 2, 441, 442, 7, 113, 2, 2, 442, 443, 7, 119, 2, 2, 443, 444, 7, 118, 2, 2, 444, 58, 3, 2, 2, 2, 445, 446, 7, 106, 2, 2, 446, 447, 7, 99, 2, 2, 447, 448, 7, 120, 2, 2, 448, 449, 7, 113, 2, 2, 449, 450, 7, 101, 2, 2, 450, 60, 3, 2, 2, 2, 451, 452, 7, 101, 2, 2, 452, 453, 7, 106, 2, 2, 453, 454, 7, 113, 2, 2, 454, 455, 7, 113, 2, 2, 455, 456, 7, 117, 2, 2, 456, 457, 7, 103, 2, 2, 457, 62, 3, 2, 2, 2, 458, 459, 7, 119, 2, 2, 459, 460, 7, 112, 2, 2, 460, 461, 7, 107, 2, 2, 461, 462, 7, 104, 2, 2, 462, 463, 7, 113, 2, 2, 463, 464, 7, 116, 2, 2, 464, 465, 7, 111, 2, 2, 465, 64, 3, 2, 2, 2, 466, 467, 7, 116, 2, 2, 467, 468, 7, 103, 2, 2, 468, 469, 7, 114, 2, 2, 469, 470, 7, 103, 2, 2, 470, 471, 7, 99, 2, 2, 471, 472, 7, 118, 2, 2, 472, 66, 3, 2, 2, 2, 473, 474, 7, 116, 2, 2, 474, 475, 7, 103, 2, 2, 475, 476, 7, 118, 2, 2, 476, 477, 7, 119, 2, 2, 477, 478, 7, 116, 2, 2, 478, 479, 7, 112, 2, 2, 479, 68, 3, 2, 2, 2, 480, 481, 7, 117, 2, 2, 481, 482, 7, 119, 2, 2, 482, 483, 7, 101, 2, 2, 483, 484, 7, 101, 2, 2, 484, 485, 7, 103, 2, 2, 485, 486, 7, 117, 2, 2, 486, 487, 7, 117, 2, 2, 487, 70, 3, 2, 2, 2, 488, 489, 7, 119, 2, 2, 489, 490, 7, 112, 2, 2, 490, 491, 7, 118, 2, 2, 491, 492, 7, 107, 2, 2, 492, 493, 7, 110, 2, 2, 493, 72, 3, 2, 2, 2, 494, 495, 7, 104, 2, 2, 495, 496, 7, 99, 2, 2, 496, 497, 7, 107, 2, 2, 497, 498, 7, 110, 2, 2, 498, 499, 7, 119, 2, 2, 499, 500, 7, 116, 2, 2, 500, 501, 7, 103, 2, 2, 501, 74, 3, 2, 2, 2, 502, 503, 7, 101, 2, 2, 503, 504, 7, 113, 2, 2, 504, 505, 7, 112, 2, 2, 505, 506, 7, 118, 2, 2, 506, 507, 7, 107, 2, 2, 507, 508, 7, 112, 2, 2, 508, 509, 7, 119, 2, 2, 509, 510, 7, 103, 2, 2, 510, 76, 3, 2, 2, 2, 511, 512, 7, 100, 2, 2, 512, 513, 7, 116, 2, 2, 513, 514, 7, 103, 2, 2, 514, 515, 7, 99, 2, 2, 515, 516, 7, 109, 2, 2, 516, 78, 3, 2, 2, 2, 517, 518, 7, 103, 2, 2, 518, 519, 7, 111, 2, 2, 519, 520, 7, 114, 2, 2, 520, 521, 7, 118, 2, 2, 521, 522, 7, 123, 2, 2, 522, 523, 7, 85, 2, 2, 523, 524, 7, 103, 2, 2, 524, 525, 7, 118, 2, 2, 525, 80, 3, 2, 2, 2, 526, 527, 7, 103, 2, 2, 527, 528, 7, 111, 2, 2, 528, 529, 7, 114, 2, 2, 529, 530, 7, 118, 2, 2, 530, 531, 7, 123, 2, 2, 531, 532, 7, 78, 2, 2, 532, 533, 7, 107, 2, 2, 533, 534, 7, 117, 2, 2, 534, 535, 7, 118, 2, 2, 535, 82, 3, 2, 2, 2, 536, 537, 7, 103, 2, 2, 537, 538, 7, 111, 2, 2, 538, 539, 7, 114, 2, 2, 539, 540, 7, 118, 2, 2, 540, 541, 7, 123, 2, 2, 541, 542, 7, 85, 2, 2, 542, 543, 7, 118, 2, 2, 543, 544, 7, 116, 2, 2, 544, 545, 7, 119, 2, 2, 545, 546, 7, 101, 2, 2, 546, 547, 7, 118, 2, 2, 547, 548, 7, 119, 2, 2, 548, 549, 7, 116, 2, 2, 549, 550, 7, 103, 2, 2, 550, 84, 3, 2, 2, 2, 551, 552, 7, 111, 2, 2, 552, 553, 7, 113, 2, 2, 553, 554, 7, 102, 2, 2, 554, 555, 7, 107, 2, 2, 555, 556, 7, 104, 2, 2, 556, 557, 7, 107, 2, 2, 557, 558, 7, 103, 2, 2, 558, 559, 7, 117, 2, 2, 559, 86, 3, 2, 2, 2, 560, 561, 7, 119, 2, 2, 561, 562, 7, 117, 2, 2, 562, 563, 7, 103, 2, 2, 563, 564, 7, 117, 2, 2, 564, 88, 3, 2, 2, 2, 565, 566, 7, 107, 2, 2, 566, 567, 7, 112, 2, 2, 567, 568, 7, 101, 2, 2, 568, 569, 7, 110, 2, 2, 569, 570, 7, 119, 2, 2, 570, 571, 7, 102, 2, 2, 571, 572, 7, 103, 2, 2, 572, 90, 3, 2, 2, 2, 573, 574, 7, 122, 2, 2, 574, 575, 7, 113, 2, 2, 575, 576, 7, 116, 2, 2, 576, 92, 3, 2, 2, 2, 577, 578, 7, 99, 2, 2, 578, 579, 7, 100, 2, 2, 579, 580, 7, 117, 2, 2, 580, 94, 3, 2, 2, 2, 581, 582, 7, 99, 2, 2, 582, 583, 7, 101, 2, 2, 583, 584, 7, 113, 2, 2, 584, 585, 7, 117, 2, 2, 585, 96, 3, 2, 2, 2, 586, 587, 7, 99, 2, 2, 587, 588, 7, 117, 2, 2, 588, 589, 7, 107, 2, 2, 589, 590, 7, 112, 2, 2, 590, 98, 3, 2, 2, 2, 591, 592, 7, 99, 2, 2, 592, 593, 7, 118, 2, 2, 593, 594, 7, 99, 2, 2, 594, 595, 7, 112, 2, 2, 595, 100, 3, 2, 2, 2, 596, 597, 7, 101, 2, 2, 597, 598, 7, 113, 2, 2, 598, 599, 7, 117, 2, 2, 599, 102, 3, 2, 2, 2, 600, 601, 7, 110, 2, 2, 601, 602, 7, 113, 2, 2, 602, 603, 7, 105, 2, 2, 603, 104, 3, 2, 2, 2, 604, 605, 7, 114, 2, 2, 605, 606, 7, 107, 2, 2, 606, 106, 3, 2, 2, 2, 607, 608, 7, 114, 2, 2, 608, 609, 7, 113, 2, 2, 609, 610, 7, 121, 2, 2, 610, 108, 3, 2, 2, 2, 611, 612, 7, 117, 2, 2, 612, 613, 7, 107, 2, 2, 613, 614, 7, 112, 2, 2, 614, 110, 3, 2, 2, 2, 615, 616, 7, 117, 2, 2, 616, 617, 7, 115, 2, 2, 617, 618, 7, 116, 2, 2, 618, 619, 7, 118, 2, 2, 619, 112, 3, 2, 2, 2, 620, 621, 7, 118, 2, 2, 621, 622, 7, 99, 2, 2, 622, 623, 7, 112, 2, 2, 623, 114, 3, 2, 2, 2, 624, 625, 7, 110, 2, 2, 625, 626, 7, 103, 2, 2, 626, 627, 7, 112, 2, 2, 627, 116, 3, 2, 2, 2, 628, 629, 7, 99, 2, 2, 629, 630, 7, 116, 2, 2, 630, 631, 7, 116, 2, 2, 631, 632, 7, 99, 2, 2, 632, 633, 7, 123, 2, 2, 633, 118, 3, 2, 2, 2, 634, 635, 7, 117, 2, 2, 635, 636, 7, 103, 2, 2, 636, 637, 7, 118, 2, 2, 637, 120, 3, 2, 2, 2, 638, 639, 7, 99, 2, 2, 639, 640, 7, 118, 2, 2, 640, 122, 3, 2, 2, 2, 641, 642, 7, 100, 2, 2, 642, 643, 7, 103, 2, 2, 643, 644, 7, 110, 2, 2, 644, 645, 7, 113, 2, 2, 645, 646, 7, 112, 2, 2, 646, 647, 7, 105, 2, 2, 647, 648, 7, 117, 2, 2, 648, 649, 7, 86, 2, 2, 649, 650, 7, 113, 2, 2, 650, 124, 3, 2, 2, 2, 651, 652, 7, 102, 2, 2, 652, 653, 7, 103, 2, 2, 653, 654, 7, 110, 2, 2, 654, 655, 7, 103, 2, 2, 655, 656, 7, 118, 2, 2, 656, 657, 7, 103, 2, 2, 657, 126, 3, 2, 2, 2, 658, 659, 7, 103, 2, 2, 659, 660, 7, 111, 2, 2, 660, 661, 7, 114, 2, 2, 661, 662, 7, 118, 2, 2, 662, 663, 7, 123, 2, 2, 663, 128, 3, 2, 2, 2, 664, 665, 7, 103, 2, 2, 665, 666, 7, 112, 2, 2, 666, 667, 7, 102, 2, 2, 667, 130, 3, 2, 2, 2, 668, 669, 7, 104, 2, 2, 669, 670, 7, 107, 2, 2, 670, 671, 7, 116, 2, 2, 671, 672, 7, 117, 2, 2, 672, 673, 7, 118, 2, 2, 673, 132, 3, 2, 2, 2, 674, 675, 7, 104, 2, 2, 675, 676, 7, 110, 2, 2, 676, 677, 7, 113, 2, 2, 677, 678, 7, 99, 2, 2, 678, 679, 7, 118, 2, 2, 679, 134, 3, 2, 2, 2, 680, 681, 7, 107, 2, 2, 681, 682, 7, 112, 2, 2, 682, 683, 7, 117, 2, 2, 683, 684, 7, 103, 2, 2, 684, 685, 7, 116, 2, 2, 685, 686, 7, 118, 2, 2, 686, 136, 3, 2, 2, 2, 687, 688, 7, 107, 2, 2, 688, 689, 7, 112, 2, 2, 689, 690, 7, 118, 2, 2, 690, 138, 3, 2, 2, 2, 691, 692, 7, 100, 2, 2, 692, 693, 7, 113, 2, 2, 693, 694, 7, 113, 2, 2, 694, 695, 7, 110, 2, 2, 695, 696, 7, 103, 2, 2, 696, 697, 7, 99, 2, 2, 697, 698, 7, 112, 2, 2, 698, 140, 3, 2, 2, 2, 699, 700, 7, 114, 2, 2, 700, 701, 7, 116, 2, 2, 701, 702, 7, 107, 2, 2, 702, 703, 7, 112, 2, 2, 703, 704, 7, 118, 2, 2, 704, 142, 3, 2, 2, 2, 705, 706, 7, 114, 2, 2, 706, 707, 7, 113, 2, 2, 707, 708, 7, 114, 2, 2, 708, 709, 7, 68, 2, 2, 709, 710, 7, 99, 2, 2, 710, 711, 7, 101, 2, 2, 711, 712, 7, 109, 2, 2, 712, 144, 3, 2, 2, 2, 713, 714, 7, 114, 2, 2, 714, 715, 7, 113, 2, 2, 715, 716, 7, 114, 2, 2, 716, 717, 7, 72, 2, 2, 717, 718, 7, 116, 2, 2, 718, 719, 7, 113, 2, 2, 719, 720, 7, 112, 2, 2, 720, 721, 7, 118, 2, 2, 721, 146, 3, 2, 2, 2, 722, 723, 7, 114, 2, 2, 723, 724, 7, 119, 2, 2, 724, 725, 7, 117, 2, 2, 725, 726, 7, 106, 2, 2, 726, 727, 7, 68, 2, 2, 727, 728, 7, 99, 2, 2, 728, 729, 7, 101, 2, 2, 729, 730, 7, 109, 2, 2, 730, 148, 3, 2, 2, 2, 731, 732, 7, 114, 2, 2, 732, 733, 7, 119, 2, 2, 733, 734, 7, 117, 2, 2, 734, 735, 7, 106, 2, 2, 735, 736, 7, 72, 2, 2, 736, 737, 7, 116, 2, 2, 737, 738, 7, 113, 2, 2, 738, 739, 7, 112, 2, 2, 739, 740, 7, 118, 2, 2, 740, 150, 3, 2, 2, 2, 741, 742, 7, 116, 2, 2, 742, 743, 7, 103, 2, 2, 743, 744, 7, 111, 2, 2, 744, 745, 7, 113, 2, 2, 745, 746, 7, 120, 2, 2, 746, 747, 7, 103, 2, 2, 747, 152, 3, 2, 2, 2, 748, 749, 7, 116, 2, 2, 749, 750, 7, 103, 2, 2, 750, 751, 7, 111, 2, 2, 751, 752, 7, 113, 2, 2, 752, 753, 7, 120, 2, 2, 753, 754, 7, 103, 2, 2, 754, 755, 7, 67, 2, 2, 755, 756, 7, 110, 2, 2, 756, 757, 7, 110, 2, 2, 757, 758, 7, 71, 2, 2, 758, 759, 7, 115, 2, 2, 759, 760, 7, 86, 2, 2, 760, 761, 7, 113, 2, 2, 761, 154, 3, 2, 2, 2, 762, 763, 7, 116, 2, 2, 763, 764, 7, 103, 2, 2, 764, 765, 7, 111, 2, 2, 765, 766, 7, 113, 2, 2, 766, 767, 7, 120, 2, 2, 767, 768, 7, 103, 2, 2, 768, 769, 7, 67, 2, 2, 769, 770, 7, 118, 2, 2, 770, 156, 3, 2, 2, 2, 771, 772, 7, 117, 2, 2, 772, 773, 7, 107, 2, 2, 773, 774, 7, 112, 2, 2, 774, 775, 7, 105, 2, 2, 775, 776, 7, 110, 2, 2, 776, 777, 7, 103, 2, 2, 777, 778, 7, 118, 2, 2, 778, 779, 7, 113, 2, 2, 779, 780, 7, 112, 2, 2, 780, 781, 7, 85, 2, 2, 781, 782, 7, 103, 2, 2, 782, 783, 7, 118, 2, 2, 783, 158, 3, 2, 2, 2, 784, 785, 7, 117, 2, 2, 785, 786, 7, 107, 2, 2, 786, 787, 7, 124, 2, 2, 787, 788, 7, 103, 2, 2, 788, 160, 3, 2, 2, 2, 789, 790, 7, 117, 2, 2, 790, 791, 7, 114, 2, 2, 791, 792, 7, 110, 2, 2, 792, 793, 7, 107, 2, 2, 793, 794, 7, 118, 2, 2, 794, 162, 3, 2, 2, 2, 795, 796, 7, 118, 2, 2, 796, 797, 7, 113, 2, 2, 797, 798, 7, 114, 2, 2, 798, 799, 7, 68, 2, 2, 799, 800, 7, 99, 2, 2, 800, 801, 7, 101, 2, 2, 801, 802, 7, 109, 2, 2, 802, 164, 3, 2, 2, 2, 803, 804, 7, 118, 2, 2, 804, 805, 7, 113, 2, 2, 805, 806, 7, 114, 2, 2, 806, 807, 7, 72, 2, 2, 807, 808, 7, 116, 2, 2, 808, 809, 7, 113, 2, 2, 809, 810, 7, 112, 2, 2, 810, 811, 7, 118, 2, 2, 811, 166, 3, 2, 2, 2, 812, 813, 7, 119, 2, 2, 813, 814, 7, 114, 2, 2, 814, 815, 7, 102, 2, 2, 815, 816, 7, 99, 2, 2, 816, 817, 7, 118, 2, 2, 817, 818, 7, 103, 2, 2, 818, 168, 3, 2, 2, 2, 819, 820, 7, 119, 2, 2, 820, 821, 7, 112, 2, 2, 821, 822, 7, 107, 2, 2, 822, 823, 7, 104, 2, 2, 823, 824, 7, 113, 2, 2, 824, 825, 7, 116, 2, 2, 825, 826, 7, 111, 2, 2, 826, 827, 7, 80, 2, 2, 827, 828, 7, 99, 2, 2, 828, 829, 7, 118, 2, 2, 829, 170, 3, 2, 2, 2, 830, 831, 7, 104, 2, 2, 831, 832, 7, 110, 2, 2, 832, 833, 7, 107, 2, 2, 833, 834, 7, 114, 2, 2, 834, 172, 3, 2, 2, 2, 835, 836, 7, 119, 2, 2, 836, 837, 7, 112, 2, 2, 837, 838, 7, 107, 2, 2, 838, 839, 7, 104, 2, 2, 839, 840, 7, 113, 2, 2, 840, 841, 7, 116, 2, 2, 841, 842, 7, 111, 2, 2, 842, 843, 7, 72, 2, 2, 843, 844, 7, 110, 2, 2, 844, 845, 7, 113, 2, 2, 845, 846, 7, 99, 2, 2, 846, 847, 7, 118, 2, 2, 847, 174, 3, 2, 2, 2, 848, 849, 7, 119, 2, 2, 849, 850, 7, 112, 2, 2, 850, 851, 7, 107, 2, 2, 851, 852, 7, 104, 2, 2, 852, 853, 7, 113, 2, 2, 853, 854, 7, 116, 2, 2, 854, 855, 7, 111, 2, 2, 855, 856, 7, 82, 2, 2, 856, 857, 7, 103, 2, 2, 857, 858, 7, 116, 2, 2, 858, 859, 7, 111, 2, 2, 859, 176, 3, 2, 2, 2, 860, 861, 7, 117, 2, 2, 861, 862, 7, 48, 2, 2, 862, 863, 7, 118, 2, 2, 863, 864, 7, 48, 2, 2, 864, 178, 3, 2, 2, 2, 865, 866, 7, 38, 2, 2, 866, 180, 3, 2, 2, 2, 867, 868, 7, 47, 2, 2, 868, 869, 7, 64, 2, 2, 869, 182, 3, 2, 2, 2, 870, 871, 7, 37, 2, 2, 871, 184, 3, 2, 2, 2, 872, 873, 7, 66, 2, 2, 873, 186, 3, 2, 2, 2, 874, 875, 7, 69, 2, 2, 875, 876, 7, 113, 2, 2, 876, 877, 7, 119, 2, 2, 877, 878, 7, 112, 2, 2, 878, 879, 7, 118, 2, 2, 879, 188, 3, 2, 2, 2, 880, 881, 7, 87, 2, 2, 881, 190, 3, 2, 2, 2, 882, 883, 7, 96, 2, 2, 883, 192, 3, 2, 2, 2, 884, 885, 7, 94, 2, 2, 885, 194, 3, 2, 2, 2, 886, 888, 9, 5, 2, 2, 887, 886, 3, 2, 2, 2, 888, 889, 3, 2, 2, 2, 889, 887, 3, 2, 2, 2, 889, 890, 3, 2, 2, 2, 890, 196, 3, 2, 2, 2, 891, 893, 9, 5, 2, 2, 892, 891, 3, 2, 2, 2, 893, 894, 3, 2, 2, 2, 894, 892, 3, 2, 2, 2, 894, 895, 3, 2, 2, 2, 895, 896, 3, 2, 2, 2, 896, 898, 5, 267, 134, 2, 897, 899, 9, 5, 2, 2, 898, 897, 3, 2, 2, 2, 899, 900, 3, 2, 2, 2, 900, 898, 3, 2, 2, 2, 900, 901, 3, 2, 2, 2, 901, 198, 3, 2, 2, 2, 902, 903, 7, 118, 2, 2, 903, 904, 7, 116, 2, 2, 904, 905, 7, 119, 2, 2, 905, 912, 7, 103, 2, 2, 906, 907, 7, 104, 2, 2, 907, 908, 7, 99, 2, 2, 908, 909, 7, 110, 2, 2, 909, 910, 7, 117, 2, 2, 910, 912, 7, 103, 2, 2, 911, 902, 3, 2, 2, 2, 911, 906, 3, 2, 2, 2, 912, 200, 3, 2, 2, 2, 913, 918, 5, 9, 5, 2, 914, 917, 5, 11, 6, 2, 915, 917, 5, 9, 5, 2, 916, 914, 3, 2, 2, 2, 916, 915, 3, 2, 2, 2, 917, 920, 3, 2, 2, 2, 918, 916, 3, 2, 2, 2, 918, 919, 3, 2, 2, 2, 919, 202, 3, 2, 2, 2, 920, 918, 3, 2, 2, 2, 921, 922, 7, 45, 2, 2, 922, 923, 7, 45, 2, 2, 923, 204, 3, 2, 2, 2, 924, 925, 7, 47, 2, 2, 925, 926, 7, 47, 2, 2, 926, 206, 3, 2, 2, 2, 927, 928, 7, 40, 2, 2, 928, 208, 3, 2, 2, 2, 929, 930, 7, 45, 2, 2, 930, 931, 7, 39, 2, 2, 931, 210, 3, 2, 2, 2, 932, 933, 7, 47, 2, 2, 933, 934, 7, 39, 2, 2, 934, 212, 3, 2, 2, 2, 935, 936, 7, 45, 2, 2, 936, 937, 7, 45, 2, 2, 937, 938, 7, 39, 2, 2, 938, 214, 3, 2, 2, 2, 939, 940, 7, 47, 2, 2, 940, 941, 7, 47, 2, 2, 941, 942, 7, 39, 2, 2, 942, 216, 3, 2, 2, 2, 943, 944, 7, 62, 2, 2, 944, 218, 3, 2, 2, 2, 945, 946, 7, 64, 2, 2, 946, 220, 3, 2, 2, 2, 947, 948, 7, 62, 2, 2, 948, 949, 7, 63, 2, 2, 949, 222, 3, 2, 2, 2, 950, 951, 7, 64, 2, 2, 951, 952, 7, 63, 2, 2, 952, 224, 3, 2, 2, 2, 953, 954, 7, 63, 2, 2, 954, 955, 7, 63, 2, 2, 955, 226, 3, 2, 2, 2, 956, 957, 7, 35, 2, 2, 957, 958, 7, 63, 2, 2, 958, 228, 3, 2, 2, 2, 959, 981, 7, 63, 2, 2, 960, 961, 7, 45, 2, 2, 961, 981, 7, 63, 2, 2, 962, 963, 7, 47, 2, 2, 963, 981, 7, 63, 2, 2, 964, 965, 7, 44, 2, 2, 965, 981, 7, 63, 2, 2, 966, 967, 7, 49, 2, 2, 967, 981, 7, 63, 2, 2, 968, 969, 7, 39, 2, 2, 969, 981, 7, 63, 2, 2, 970, 971, 7, 62, 2, 2, 971, 972, 7, 62, 2, 2, 972, 981, 7, 63, 2, 2, 973, 974, 7, 64, 2, 2, 974, 975, 7, 64, 2, 2, 975, 981, 7, 63, 2, 2, 976, 977, 7, 40, 2, 2, 977, 981, 7, 63, 2, 2, 978, 979, 7, 126, 2, 2, 979, 981, 7, 63, 2, 2, 980, 959, 3, 2, 2, 2, 980, 960, 3, 2, 2, 2, 980, 962, 3, 2, 2, 2, 980, 964, 3, 2, 2, 2, 980, 966, 3, 2, 2, 2, 980, 968, 3, 2, 2, 2, 980, 970, 3, 2, 2, 2, 980, 973, 3, 2, 2, 2, 980, 976, 3, 2, 2, 2, 980, 978, 3, 2, 2, 2, 981, 230, 3, 2, 2, 2, 982, 983, 7, 47, 2, 2, 983, 232, 3, 2, 2, 2, 984, 985, 7, 45, 2, 2, 985, 234, 3, 2, 2, 2, 986, 987, 7, 44, 2, 2, 987, 236, 3, 2, 2, 2, 988, 989, 7, 49, 2, 2, 989, 238, 3, 2, 2, 2, 990, 991, 7, 39, 2, 2, 991, 240, 3, 2, 2, 2, 992, 993, 7, 42, 2, 2, 993, 242, 3, 2, 2, 2, 994, 995, 7, 43, 2, 2, 995, 244, 3, 2, 2, 2, 996, 997, 7, 62, 2, 2, 997, 998, 7, 62, 2, 2, 998, 246, 3, 2, 2, 2, 999, 1000, 7, 64, 2, 2, 1000, 1001, 7, 64, 2, 2, 1001, 248, 3, 2, 2, 2, 1002, 1003, 7, 126, 2, 2, 1003, 1004, 7, 126, 2, 2, 1004, 250, 3, 2, 2, 2, 1005, 1006, 7, 40, 2, 2, 1006, 1007, 7, 40, 2, 2, 1007, 252, 3, 2, 2, 2, 1008, 1009, 7, 35, 2, 2, 1009, 254, 3, 2, 2, 2, 1010, 1011, 7, 61, 2, 2, 1011, 256, 3, 2, 2, 2, 1012, 1013, 7, 60, 2, 2, 1013, 258, 3, 2, 2, 2, 1014, 1015, 7, 126, 2, 2, 1015, 260, 3, 2, 2, 2, 1016, 1017, 7, 125, 2, 2, 1017, 262, 3, 2, 2, 2, 1018, 1019, 7, 127, 2, 2, 1019, 264, 3, 2, 2, 2, 1020, 1021, 7, 46, 2, 2, 1021, 266, 3, 2, 2, 2, 1022, 1023, 7, 48, 2, 2, 1023, 268, 3, 2, 2, 2, 1024, 1025, 7, 93, 2, 2, 1025, 270, 3, 2, 2, 2, 1026, 1027, 7, 95, 2, 2, 1027, 272, 3, 2, 2, 2, 1028, 1029, 7, 36, 2, 2, 1029, 274, 3, 2, 2, 2, 1030, 1031, 7, 65, 2, 2, 1031, 276, 3, 2, 2, 2, 1032, 1036, 7, 36, 2, 2, 1033, 1035, 10, 7, 2, 2, 1034, 1033, 3, 2, 2, 2, 1035, 1038, 3, 2, 2, 2, 1036, 1034, 3, 2, 2, 2, 1036, 1037, 3, 2, 2, 2, 1037, 1039, 3, 2, 2, 2, 1038, 1036, 3, 2, 2, 2, 1039, 1040, 7, 36, 2, 2, 1040, 278, 3, 2, 2, 2, 14, 2, 282, 292, 306, 889, 894, 900, 911, 916, 918, 980, 1036, 3, 8, 2, 2] \ No newline at end of file +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 138, 1052, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 3, 2, 6, 2, 283, 10, 2, 13, 2, 14, 2, 284, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 7, 3, 293, 10, 3, 12, 3, 14, 3, 296, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 7, 4, 307, 10, 4, 12, 4, 14, 4, 310, 11, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 97, 3, 97, 3, 98, 3, 98, 3, 99, 6, 99, 899, 10, 99, 13, 99, 14, 99, 900, 3, 100, 6, 100, 904, 10, 100, 13, 100, 14, 100, 905, 3, 100, 3, 100, 6, 100, 910, 10, 100, 13, 100, 14, 100, 911, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 923, 10, 101, 3, 102, 3, 102, 3, 102, 7, 102, 928, 10, 102, 12, 102, 14, 102, 931, 11, 102, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 5, 116, 992, 10, 116, 3, 117, 3, 117, 3, 118, 3, 118, 3, 119, 3, 119, 3, 120, 3, 120, 3, 121, 3, 121, 3, 122, 3, 122, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 129, 3, 129, 3, 130, 3, 130, 3, 131, 3, 131, 3, 132, 3, 132, 3, 133, 3, 133, 3, 134, 3, 134, 3, 135, 3, 135, 3, 136, 3, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 3, 140, 3, 140, 7, 140, 1046, 10, 140, 12, 140, 14, 140, 1049, 11, 140, 3, 140, 3, 140, 3, 294, 2, 141, 3, 3, 5, 4, 7, 5, 9, 2, 11, 2, 13, 2, 15, 6, 17, 7, 19, 8, 21, 9, 23, 10, 25, 11, 27, 12, 29, 13, 31, 14, 33, 15, 35, 16, 37, 17, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 30, 65, 31, 67, 32, 69, 33, 71, 34, 73, 35, 75, 36, 77, 37, 79, 38, 81, 39, 83, 40, 85, 41, 87, 42, 89, 43, 91, 44, 93, 45, 95, 46, 97, 47, 99, 48, 101, 49, 103, 50, 105, 51, 107, 52, 109, 53, 111, 54, 113, 55, 115, 56, 117, 57, 119, 58, 121, 59, 123, 60, 125, 61, 127, 62, 129, 63, 131, 64, 133, 65, 135, 66, 137, 67, 139, 68, 141, 69, 143, 70, 145, 71, 147, 72, 149, 73, 151, 74, 153, 75, 155, 76, 157, 77, 159, 78, 161, 79, 163, 80, 165, 81, 167, 82, 169, 83, 171, 84, 173, 85, 175, 86, 177, 87, 179, 88, 181, 89, 183, 90, 185, 91, 187, 92, 189, 93, 191, 94, 193, 95, 195, 96, 197, 97, 199, 98, 201, 99, 203, 100, 205, 101, 207, 102, 209, 103, 211, 104, 213, 105, 215, 106, 217, 107, 219, 108, 221, 109, 223, 110, 225, 111, 227, 112, 229, 113, 231, 114, 233, 115, 235, 116, 237, 117, 239, 118, 241, 119, 243, 120, 245, 121, 247, 122, 249, 123, 251, 124, 253, 125, 255, 126, 257, 127, 259, 128, 261, 129, 263, 130, 265, 131, 267, 132, 269, 133, 271, 134, 273, 135, 275, 136, 277, 137, 279, 138, 3, 2, 8, 5, 2, 11, 12, 15, 15, 34, 34, 4, 2, 12, 12, 15, 15, 5, 2, 67, 92, 97, 97, 99, 124, 3, 2, 50, 59, 3, 2, 51, 59, 5, 2, 12, 12, 15, 15, 36, 36, 2, 1067, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 2, 197, 3, 2, 2, 2, 2, 199, 3, 2, 2, 2, 2, 201, 3, 2, 2, 2, 2, 203, 3, 2, 2, 2, 2, 205, 3, 2, 2, 2, 2, 207, 3, 2, 2, 2, 2, 209, 3, 2, 2, 2, 2, 211, 3, 2, 2, 2, 2, 213, 3, 2, 2, 2, 2, 215, 3, 2, 2, 2, 2, 217, 3, 2, 2, 2, 2, 219, 3, 2, 2, 2, 2, 221, 3, 2, 2, 2, 2, 223, 3, 2, 2, 2, 2, 225, 3, 2, 2, 2, 2, 227, 3, 2, 2, 2, 2, 229, 3, 2, 2, 2, 2, 231, 3, 2, 2, 2, 2, 233, 3, 2, 2, 2, 2, 235, 3, 2, 2, 2, 2, 237, 3, 2, 2, 2, 2, 239, 3, 2, 2, 2, 2, 241, 3, 2, 2, 2, 2, 243, 3, 2, 2, 2, 2, 245, 3, 2, 2, 2, 2, 247, 3, 2, 2, 2, 2, 249, 3, 2, 2, 2, 2, 251, 3, 2, 2, 2, 2, 253, 3, 2, 2, 2, 2, 255, 3, 2, 2, 2, 2, 257, 3, 2, 2, 2, 2, 259, 3, 2, 2, 2, 2, 261, 3, 2, 2, 2, 2, 263, 3, 2, 2, 2, 2, 265, 3, 2, 2, 2, 2, 267, 3, 2, 2, 2, 2, 269, 3, 2, 2, 2, 2, 271, 3, 2, 2, 2, 2, 273, 3, 2, 2, 2, 2, 275, 3, 2, 2, 2, 2, 277, 3, 2, 2, 2, 2, 279, 3, 2, 2, 2, 3, 282, 3, 2, 2, 2, 5, 288, 3, 2, 2, 2, 7, 302, 3, 2, 2, 2, 9, 313, 3, 2, 2, 2, 11, 315, 3, 2, 2, 2, 13, 317, 3, 2, 2, 2, 15, 319, 3, 2, 2, 2, 17, 326, 3, 2, 2, 2, 19, 333, 3, 2, 2, 2, 21, 342, 3, 2, 2, 2, 23, 352, 3, 2, 2, 2, 25, 361, 3, 2, 2, 2, 27, 369, 3, 2, 2, 2, 29, 376, 3, 2, 2, 2, 31, 380, 3, 2, 2, 2, 33, 385, 3, 2, 2, 2, 35, 392, 3, 2, 2, 2, 37, 399, 3, 2, 2, 2, 39, 402, 3, 2, 2, 2, 41, 406, 3, 2, 2, 2, 43, 409, 3, 2, 2, 2, 45, 414, 3, 2, 2, 2, 47, 420, 3, 2, 2, 2, 49, 423, 3, 2, 2, 2, 51, 427, 3, 2, 2, 2, 53, 435, 3, 2, 2, 2, 55, 438, 3, 2, 2, 2, 57, 443, 3, 2, 2, 2, 59, 447, 3, 2, 2, 2, 61, 453, 3, 2, 2, 2, 63, 460, 3, 2, 2, 2, 65, 468, 3, 2, 2, 2, 67, 475, 3, 2, 2, 2, 69, 482, 3, 2, 2, 2, 71, 490, 3, 2, 2, 2, 73, 496, 3, 2, 2, 2, 75, 504, 3, 2, 2, 2, 77, 513, 3, 2, 2, 2, 79, 519, 3, 2, 2, 2, 81, 528, 3, 2, 2, 2, 83, 537, 3, 2, 2, 2, 85, 547, 3, 2, 2, 2, 87, 562, 3, 2, 2, 2, 89, 571, 3, 2, 2, 2, 91, 576, 3, 2, 2, 2, 93, 584, 3, 2, 2, 2, 95, 588, 3, 2, 2, 2, 97, 592, 3, 2, 2, 2, 99, 597, 3, 2, 2, 2, 101, 602, 3, 2, 2, 2, 103, 607, 3, 2, 2, 2, 105, 611, 3, 2, 2, 2, 107, 615, 3, 2, 2, 2, 109, 618, 3, 2, 2, 2, 111, 622, 3, 2, 2, 2, 113, 626, 3, 2, 2, 2, 115, 631, 3, 2, 2, 2, 117, 635, 3, 2, 2, 2, 119, 639, 3, 2, 2, 2, 121, 645, 3, 2, 2, 2, 123, 649, 3, 2, 2, 2, 125, 652, 3, 2, 2, 2, 127, 662, 3, 2, 2, 2, 129, 669, 3, 2, 2, 2, 131, 675, 3, 2, 2, 2, 133, 679, 3, 2, 2, 2, 135, 685, 3, 2, 2, 2, 137, 691, 3, 2, 2, 2, 139, 698, 3, 2, 2, 2, 141, 702, 3, 2, 2, 2, 143, 710, 3, 2, 2, 2, 145, 716, 3, 2, 2, 2, 147, 724, 3, 2, 2, 2, 149, 733, 3, 2, 2, 2, 151, 742, 3, 2, 2, 2, 153, 752, 3, 2, 2, 2, 155, 759, 3, 2, 2, 2, 157, 773, 3, 2, 2, 2, 159, 782, 3, 2, 2, 2, 161, 795, 3, 2, 2, 2, 163, 800, 3, 2, 2, 2, 165, 806, 3, 2, 2, 2, 167, 814, 3, 2, 2, 2, 169, 823, 3, 2, 2, 2, 171, 830, 3, 2, 2, 2, 173, 841, 3, 2, 2, 2, 175, 846, 3, 2, 2, 2, 177, 859, 3, 2, 2, 2, 179, 871, 3, 2, 2, 2, 181, 876, 3, 2, 2, 2, 183, 878, 3, 2, 2, 2, 185, 881, 3, 2, 2, 2, 187, 883, 3, 2, 2, 2, 189, 885, 3, 2, 2, 2, 191, 891, 3, 2, 2, 2, 193, 893, 3, 2, 2, 2, 195, 895, 3, 2, 2, 2, 197, 898, 3, 2, 2, 2, 199, 903, 3, 2, 2, 2, 201, 922, 3, 2, 2, 2, 203, 924, 3, 2, 2, 2, 205, 932, 3, 2, 2, 2, 207, 935, 3, 2, 2, 2, 209, 938, 3, 2, 2, 2, 211, 940, 3, 2, 2, 2, 213, 943, 3, 2, 2, 2, 215, 946, 3, 2, 2, 2, 217, 950, 3, 2, 2, 2, 219, 954, 3, 2, 2, 2, 221, 956, 3, 2, 2, 2, 223, 958, 3, 2, 2, 2, 225, 961, 3, 2, 2, 2, 227, 964, 3, 2, 2, 2, 229, 967, 3, 2, 2, 2, 231, 991, 3, 2, 2, 2, 233, 993, 3, 2, 2, 2, 235, 995, 3, 2, 2, 2, 237, 997, 3, 2, 2, 2, 239, 999, 3, 2, 2, 2, 241, 1001, 3, 2, 2, 2, 243, 1003, 3, 2, 2, 2, 245, 1005, 3, 2, 2, 2, 247, 1007, 3, 2, 2, 2, 249, 1010, 3, 2, 2, 2, 251, 1013, 3, 2, 2, 2, 253, 1016, 3, 2, 2, 2, 255, 1019, 3, 2, 2, 2, 257, 1021, 3, 2, 2, 2, 259, 1023, 3, 2, 2, 2, 261, 1025, 3, 2, 2, 2, 263, 1027, 3, 2, 2, 2, 265, 1029, 3, 2, 2, 2, 267, 1031, 3, 2, 2, 2, 269, 1033, 3, 2, 2, 2, 271, 1035, 3, 2, 2, 2, 273, 1037, 3, 2, 2, 2, 275, 1039, 3, 2, 2, 2, 277, 1041, 3, 2, 2, 2, 279, 1043, 3, 2, 2, 2, 281, 283, 9, 2, 2, 2, 282, 281, 3, 2, 2, 2, 283, 284, 3, 2, 2, 2, 284, 282, 3, 2, 2, 2, 284, 285, 3, 2, 2, 2, 285, 286, 3, 2, 2, 2, 286, 287, 8, 2, 2, 2, 287, 4, 3, 2, 2, 2, 288, 289, 7, 49, 2, 2, 289, 290, 7, 44, 2, 2, 290, 294, 3, 2, 2, 2, 291, 293, 11, 2, 2, 2, 292, 291, 3, 2, 2, 2, 293, 296, 3, 2, 2, 2, 294, 295, 3, 2, 2, 2, 294, 292, 3, 2, 2, 2, 295, 297, 3, 2, 2, 2, 296, 294, 3, 2, 2, 2, 297, 298, 7, 44, 2, 2, 298, 299, 7, 49, 2, 2, 299, 300, 3, 2, 2, 2, 300, 301, 8, 3, 2, 2, 301, 6, 3, 2, 2, 2, 302, 303, 7, 49, 2, 2, 303, 304, 7, 49, 2, 2, 304, 308, 3, 2, 2, 2, 305, 307, 10, 3, 2, 2, 306, 305, 3, 2, 2, 2, 307, 310, 3, 2, 2, 2, 308, 306, 3, 2, 2, 2, 308, 309, 3, 2, 2, 2, 309, 311, 3, 2, 2, 2, 310, 308, 3, 2, 2, 2, 311, 312, 8, 4, 2, 2, 312, 8, 3, 2, 2, 2, 313, 314, 9, 4, 2, 2, 314, 10, 3, 2, 2, 2, 315, 316, 9, 5, 2, 2, 316, 12, 3, 2, 2, 2, 317, 318, 9, 6, 2, 2, 318, 14, 3, 2, 2, 2, 319, 320, 7, 99, 2, 2, 320, 321, 7, 117, 2, 2, 321, 322, 7, 117, 2, 2, 322, 323, 7, 103, 2, 2, 323, 324, 7, 116, 2, 2, 324, 325, 7, 118, 2, 2, 325, 16, 3, 2, 2, 2, 326, 327, 7, 99, 2, 2, 327, 328, 7, 117, 2, 2, 328, 329, 7, 117, 2, 2, 329, 330, 7, 119, 2, 2, 330, 331, 7, 111, 2, 2, 331, 332, 7, 103, 2, 2, 332, 18, 3, 2, 2, 2, 333, 334, 7, 117, 2, 2, 334, 335, 7, 123, 2, 2, 335, 336, 7, 111, 2, 2, 336, 337, 7, 100, 2, 2, 337, 338, 7, 113, 2, 2, 338, 339, 7, 110, 2, 2, 339, 340, 7, 107, 2, 2, 340, 341, 7, 101, 2, 2, 341, 20, 3, 2, 2, 2, 342, 343, 7, 107, 2, 2, 343, 344, 7, 112, 2, 2, 344, 345, 7, 120, 2, 2, 345, 346, 7, 99, 2, 2, 346, 347, 7, 116, 2, 2, 347, 348, 7, 107, 2, 2, 348, 349, 7, 99, 2, 2, 349, 350, 7, 112, 2, 2, 350, 351, 7, 118, 2, 2, 351, 22, 3, 2, 2, 2, 352, 353, 7, 116, 2, 2, 353, 354, 7, 103, 2, 2, 354, 355, 7, 115, 2, 2, 355, 356, 7, 119, 2, 2, 356, 357, 7, 107, 2, 2, 357, 358, 7, 116, 2, 2, 358, 359, 7, 103, 2, 2, 359, 360, 7, 117, 2, 2, 360, 24, 3, 2, 2, 2, 361, 362, 7, 103, 2, 2, 362, 363, 7, 112, 2, 2, 363, 364, 7, 117, 2, 2, 364, 365, 7, 119, 2, 2, 365, 366, 7, 116, 2, 2, 366, 367, 7, 103, 2, 2, 367, 368, 7, 117, 2, 2, 368, 26, 3, 2, 2, 2, 369, 370, 7, 116, 2, 2, 370, 371, 7, 103, 2, 2, 371, 372, 7, 117, 2, 2, 372, 373, 7, 119, 2, 2, 373, 374, 7, 110, 2, 2, 374, 375, 7, 118, 2, 2, 375, 28, 3, 2, 2, 2, 376, 377, 7, 63, 2, 2, 377, 378, 7, 63, 2, 2, 378, 379, 7, 64, 2, 2, 379, 30, 3, 2, 2, 2, 380, 381, 7, 62, 2, 2, 381, 382, 7, 63, 2, 2, 382, 383, 7, 63, 2, 2, 383, 384, 7, 64, 2, 2, 384, 32, 3, 2, 2, 2, 385, 386, 7, 104, 2, 2, 386, 387, 7, 113, 2, 2, 387, 388, 7, 116, 2, 2, 388, 389, 7, 99, 2, 2, 389, 390, 7, 110, 2, 2, 390, 391, 7, 110, 2, 2, 391, 34, 3, 2, 2, 2, 392, 393, 7, 103, 2, 2, 393, 394, 7, 122, 2, 2, 394, 395, 7, 107, 2, 2, 395, 396, 7, 117, 2, 2, 396, 397, 7, 118, 2, 2, 397, 398, 7, 117, 2, 2, 398, 36, 3, 2, 2, 2, 399, 400, 7, 60, 2, 2, 400, 401, 7, 60, 2, 2, 401, 38, 3, 2, 2, 2, 402, 403, 7, 126, 2, 2, 403, 404, 7, 47, 2, 2, 404, 405, 7, 64, 2, 2, 405, 40, 3, 2, 2, 2, 406, 407, 7, 107, 2, 2, 407, 408, 7, 104, 2, 2, 408, 42, 3, 2, 2, 2, 409, 410, 7, 103, 2, 2, 410, 411, 7, 110, 2, 2, 411, 412, 7, 117, 2, 2, 412, 413, 7, 103, 2, 2, 413, 44, 3, 2, 2, 2, 414, 415, 7, 121, 2, 2, 415, 416, 7, 106, 2, 2, 416, 417, 7, 107, 2, 2, 417, 418, 7, 110, 2, 2, 418, 419, 7, 103, 2, 2, 419, 46, 3, 2, 2, 2, 420, 421, 7, 102, 2, 2, 421, 422, 7, 113, 2, 2, 422, 48, 3, 2, 2, 2, 423, 424, 7, 104, 2, 2, 424, 425, 7, 113, 2, 2, 425, 426, 7, 116, 2, 2, 426, 50, 3, 2, 2, 2, 427, 428, 7, 104, 2, 2, 428, 429, 7, 113, 2, 2, 429, 430, 7, 116, 2, 2, 430, 431, 7, 103, 2, 2, 431, 432, 7, 99, 2, 2, 432, 433, 7, 101, 2, 2, 433, 434, 7, 106, 2, 2, 434, 52, 3, 2, 2, 2, 435, 436, 7, 107, 2, 2, 436, 437, 7, 112, 2, 2, 437, 54, 3, 2, 2, 2, 438, 439, 7, 104, 2, 2, 439, 440, 7, 116, 2, 2, 440, 441, 7, 113, 2, 2, 441, 442, 7, 111, 2, 2, 442, 56, 3, 2, 2, 2, 443, 444, 7, 113, 2, 2, 444, 445, 7, 119, 2, 2, 445, 446, 7, 118, 2, 2, 446, 58, 3, 2, 2, 2, 447, 448, 7, 106, 2, 2, 448, 449, 7, 99, 2, 2, 449, 450, 7, 120, 2, 2, 450, 451, 7, 113, 2, 2, 451, 452, 7, 101, 2, 2, 452, 60, 3, 2, 2, 2, 453, 454, 7, 101, 2, 2, 454, 455, 7, 106, 2, 2, 455, 456, 7, 113, 2, 2, 456, 457, 7, 113, 2, 2, 457, 458, 7, 117, 2, 2, 458, 459, 7, 103, 2, 2, 459, 62, 3, 2, 2, 2, 460, 461, 7, 119, 2, 2, 461, 462, 7, 112, 2, 2, 462, 463, 7, 107, 2, 2, 463, 464, 7, 104, 2, 2, 464, 465, 7, 113, 2, 2, 465, 466, 7, 116, 2, 2, 466, 467, 7, 111, 2, 2, 467, 64, 3, 2, 2, 2, 468, 469, 7, 116, 2, 2, 469, 470, 7, 103, 2, 2, 470, 471, 7, 114, 2, 2, 471, 472, 7, 103, 2, 2, 472, 473, 7, 99, 2, 2, 473, 474, 7, 118, 2, 2, 474, 66, 3, 2, 2, 2, 475, 476, 7, 116, 2, 2, 476, 477, 7, 103, 2, 2, 477, 478, 7, 118, 2, 2, 478, 479, 7, 119, 2, 2, 479, 480, 7, 116, 2, 2, 480, 481, 7, 112, 2, 2, 481, 68, 3, 2, 2, 2, 482, 483, 7, 117, 2, 2, 483, 484, 7, 119, 2, 2, 484, 485, 7, 101, 2, 2, 485, 486, 7, 101, 2, 2, 486, 487, 7, 103, 2, 2, 487, 488, 7, 117, 2, 2, 488, 489, 7, 117, 2, 2, 489, 70, 3, 2, 2, 2, 490, 491, 7, 119, 2, 2, 491, 492, 7, 112, 2, 2, 492, 493, 7, 118, 2, 2, 493, 494, 7, 107, 2, 2, 494, 495, 7, 110, 2, 2, 495, 72, 3, 2, 2, 2, 496, 497, 7, 104, 2, 2, 497, 498, 7, 99, 2, 2, 498, 499, 7, 107, 2, 2, 499, 500, 7, 110, 2, 2, 500, 501, 7, 119, 2, 2, 501, 502, 7, 116, 2, 2, 502, 503, 7, 103, 2, 2, 503, 74, 3, 2, 2, 2, 504, 505, 7, 101, 2, 2, 505, 506, 7, 113, 2, 2, 506, 507, 7, 112, 2, 2, 507, 508, 7, 118, 2, 2, 508, 509, 7, 107, 2, 2, 509, 510, 7, 112, 2, 2, 510, 511, 7, 119, 2, 2, 511, 512, 7, 103, 2, 2, 512, 76, 3, 2, 2, 2, 513, 514, 7, 100, 2, 2, 514, 515, 7, 116, 2, 2, 515, 516, 7, 103, 2, 2, 516, 517, 7, 99, 2, 2, 517, 518, 7, 109, 2, 2, 518, 78, 3, 2, 2, 2, 519, 520, 7, 103, 2, 2, 520, 521, 7, 111, 2, 2, 521, 522, 7, 114, 2, 2, 522, 523, 7, 118, 2, 2, 523, 524, 7, 123, 2, 2, 524, 525, 7, 79, 2, 2, 525, 526, 7, 99, 2, 2, 526, 527, 7, 114, 2, 2, 527, 80, 3, 2, 2, 2, 528, 529, 7, 103, 2, 2, 529, 530, 7, 111, 2, 2, 530, 531, 7, 114, 2, 2, 531, 532, 7, 118, 2, 2, 532, 533, 7, 123, 2, 2, 533, 534, 7, 85, 2, 2, 534, 535, 7, 103, 2, 2, 535, 536, 7, 118, 2, 2, 536, 82, 3, 2, 2, 2, 537, 538, 7, 103, 2, 2, 538, 539, 7, 111, 2, 2, 539, 540, 7, 114, 2, 2, 540, 541, 7, 118, 2, 2, 541, 542, 7, 123, 2, 2, 542, 543, 7, 78, 2, 2, 543, 544, 7, 107, 2, 2, 544, 545, 7, 117, 2, 2, 545, 546, 7, 118, 2, 2, 546, 84, 3, 2, 2, 2, 547, 548, 7, 103, 2, 2, 548, 549, 7, 111, 2, 2, 549, 550, 7, 114, 2, 2, 550, 551, 7, 118, 2, 2, 551, 552, 7, 123, 2, 2, 552, 553, 7, 85, 2, 2, 553, 554, 7, 118, 2, 2, 554, 555, 7, 116, 2, 2, 555, 556, 7, 119, 2, 2, 556, 557, 7, 101, 2, 2, 557, 558, 7, 118, 2, 2, 558, 559, 7, 119, 2, 2, 559, 560, 7, 116, 2, 2, 560, 561, 7, 103, 2, 2, 561, 86, 3, 2, 2, 2, 562, 563, 7, 111, 2, 2, 563, 564, 7, 113, 2, 2, 564, 565, 7, 102, 2, 2, 565, 566, 7, 107, 2, 2, 566, 567, 7, 104, 2, 2, 567, 568, 7, 107, 2, 2, 568, 569, 7, 103, 2, 2, 569, 570, 7, 117, 2, 2, 570, 88, 3, 2, 2, 2, 571, 572, 7, 119, 2, 2, 572, 573, 7, 117, 2, 2, 573, 574, 7, 103, 2, 2, 574, 575, 7, 117, 2, 2, 575, 90, 3, 2, 2, 2, 576, 577, 7, 107, 2, 2, 577, 578, 7, 112, 2, 2, 578, 579, 7, 101, 2, 2, 579, 580, 7, 110, 2, 2, 580, 581, 7, 119, 2, 2, 581, 582, 7, 102, 2, 2, 582, 583, 7, 103, 2, 2, 583, 92, 3, 2, 2, 2, 584, 585, 7, 122, 2, 2, 585, 586, 7, 113, 2, 2, 586, 587, 7, 116, 2, 2, 587, 94, 3, 2, 2, 2, 588, 589, 7, 99, 2, 2, 589, 590, 7, 100, 2, 2, 590, 591, 7, 117, 2, 2, 591, 96, 3, 2, 2, 2, 592, 593, 7, 99, 2, 2, 593, 594, 7, 101, 2, 2, 594, 595, 7, 113, 2, 2, 595, 596, 7, 117, 2, 2, 596, 98, 3, 2, 2, 2, 597, 598, 7, 99, 2, 2, 598, 599, 7, 117, 2, 2, 599, 600, 7, 107, 2, 2, 600, 601, 7, 112, 2, 2, 601, 100, 3, 2, 2, 2, 602, 603, 7, 99, 2, 2, 603, 604, 7, 118, 2, 2, 604, 605, 7, 99, 2, 2, 605, 606, 7, 112, 2, 2, 606, 102, 3, 2, 2, 2, 607, 608, 7, 101, 2, 2, 608, 609, 7, 113, 2, 2, 609, 610, 7, 117, 2, 2, 610, 104, 3, 2, 2, 2, 611, 612, 7, 110, 2, 2, 612, 613, 7, 113, 2, 2, 613, 614, 7, 105, 2, 2, 614, 106, 3, 2, 2, 2, 615, 616, 7, 114, 2, 2, 616, 617, 7, 107, 2, 2, 617, 108, 3, 2, 2, 2, 618, 619, 7, 114, 2, 2, 619, 620, 7, 113, 2, 2, 620, 621, 7, 121, 2, 2, 621, 110, 3, 2, 2, 2, 622, 623, 7, 117, 2, 2, 623, 624, 7, 107, 2, 2, 624, 625, 7, 112, 2, 2, 625, 112, 3, 2, 2, 2, 626, 627, 7, 117, 2, 2, 627, 628, 7, 115, 2, 2, 628, 629, 7, 116, 2, 2, 629, 630, 7, 118, 2, 2, 630, 114, 3, 2, 2, 2, 631, 632, 7, 118, 2, 2, 632, 633, 7, 99, 2, 2, 633, 634, 7, 112, 2, 2, 634, 116, 3, 2, 2, 2, 635, 636, 7, 110, 2, 2, 636, 637, 7, 103, 2, 2, 637, 638, 7, 112, 2, 2, 638, 118, 3, 2, 2, 2, 639, 640, 7, 99, 2, 2, 640, 641, 7, 116, 2, 2, 641, 642, 7, 116, 2, 2, 642, 643, 7, 99, 2, 2, 643, 644, 7, 123, 2, 2, 644, 120, 3, 2, 2, 2, 645, 646, 7, 117, 2, 2, 646, 647, 7, 103, 2, 2, 647, 648, 7, 118, 2, 2, 648, 122, 3, 2, 2, 2, 649, 650, 7, 99, 2, 2, 650, 651, 7, 118, 2, 2, 651, 124, 3, 2, 2, 2, 652, 653, 7, 100, 2, 2, 653, 654, 7, 103, 2, 2, 654, 655, 7, 110, 2, 2, 655, 656, 7, 113, 2, 2, 656, 657, 7, 112, 2, 2, 657, 658, 7, 105, 2, 2, 658, 659, 7, 117, 2, 2, 659, 660, 7, 86, 2, 2, 660, 661, 7, 113, 2, 2, 661, 126, 3, 2, 2, 2, 662, 663, 7, 102, 2, 2, 663, 664, 7, 103, 2, 2, 664, 665, 7, 110, 2, 2, 665, 666, 7, 103, 2, 2, 666, 667, 7, 118, 2, 2, 667, 668, 7, 103, 2, 2, 668, 128, 3, 2, 2, 2, 669, 670, 7, 103, 2, 2, 670, 671, 7, 111, 2, 2, 671, 672, 7, 114, 2, 2, 672, 673, 7, 118, 2, 2, 673, 674, 7, 123, 2, 2, 674, 130, 3, 2, 2, 2, 675, 676, 7, 103, 2, 2, 676, 677, 7, 112, 2, 2, 677, 678, 7, 102, 2, 2, 678, 132, 3, 2, 2, 2, 679, 680, 7, 104, 2, 2, 680, 681, 7, 107, 2, 2, 681, 682, 7, 116, 2, 2, 682, 683, 7, 117, 2, 2, 683, 684, 7, 118, 2, 2, 684, 134, 3, 2, 2, 2, 685, 686, 7, 104, 2, 2, 686, 687, 7, 110, 2, 2, 687, 688, 7, 113, 2, 2, 688, 689, 7, 99, 2, 2, 689, 690, 7, 118, 2, 2, 690, 136, 3, 2, 2, 2, 691, 692, 7, 107, 2, 2, 692, 693, 7, 112, 2, 2, 693, 694, 7, 117, 2, 2, 694, 695, 7, 103, 2, 2, 695, 696, 7, 116, 2, 2, 696, 697, 7, 118, 2, 2, 697, 138, 3, 2, 2, 2, 698, 699, 7, 107, 2, 2, 699, 700, 7, 112, 2, 2, 700, 701, 7, 118, 2, 2, 701, 140, 3, 2, 2, 2, 702, 703, 7, 100, 2, 2, 703, 704, 7, 113, 2, 2, 704, 705, 7, 113, 2, 2, 705, 706, 7, 110, 2, 2, 706, 707, 7, 103, 2, 2, 707, 708, 7, 99, 2, 2, 708, 709, 7, 112, 2, 2, 709, 142, 3, 2, 2, 2, 710, 711, 7, 114, 2, 2, 711, 712, 7, 116, 2, 2, 712, 713, 7, 107, 2, 2, 713, 714, 7, 112, 2, 2, 714, 715, 7, 118, 2, 2, 715, 144, 3, 2, 2, 2, 716, 717, 7, 114, 2, 2, 717, 718, 7, 113, 2, 2, 718, 719, 7, 114, 2, 2, 719, 720, 7, 68, 2, 2, 720, 721, 7, 99, 2, 2, 721, 722, 7, 101, 2, 2, 722, 723, 7, 109, 2, 2, 723, 146, 3, 2, 2, 2, 724, 725, 7, 114, 2, 2, 725, 726, 7, 113, 2, 2, 726, 727, 7, 114, 2, 2, 727, 728, 7, 72, 2, 2, 728, 729, 7, 116, 2, 2, 729, 730, 7, 113, 2, 2, 730, 731, 7, 112, 2, 2, 731, 732, 7, 118, 2, 2, 732, 148, 3, 2, 2, 2, 733, 734, 7, 114, 2, 2, 734, 735, 7, 119, 2, 2, 735, 736, 7, 117, 2, 2, 736, 737, 7, 106, 2, 2, 737, 738, 7, 68, 2, 2, 738, 739, 7, 99, 2, 2, 739, 740, 7, 101, 2, 2, 740, 741, 7, 109, 2, 2, 741, 150, 3, 2, 2, 2, 742, 743, 7, 114, 2, 2, 743, 744, 7, 119, 2, 2, 744, 745, 7, 117, 2, 2, 745, 746, 7, 106, 2, 2, 746, 747, 7, 72, 2, 2, 747, 748, 7, 116, 2, 2, 748, 749, 7, 113, 2, 2, 749, 750, 7, 112, 2, 2, 750, 751, 7, 118, 2, 2, 751, 152, 3, 2, 2, 2, 752, 753, 7, 116, 2, 2, 753, 754, 7, 103, 2, 2, 754, 755, 7, 111, 2, 2, 755, 756, 7, 113, 2, 2, 756, 757, 7, 120, 2, 2, 757, 758, 7, 103, 2, 2, 758, 154, 3, 2, 2, 2, 759, 760, 7, 116, 2, 2, 760, 761, 7, 103, 2, 2, 761, 762, 7, 111, 2, 2, 762, 763, 7, 113, 2, 2, 763, 764, 7, 120, 2, 2, 764, 765, 7, 103, 2, 2, 765, 766, 7, 67, 2, 2, 766, 767, 7, 110, 2, 2, 767, 768, 7, 110, 2, 2, 768, 769, 7, 71, 2, 2, 769, 770, 7, 115, 2, 2, 770, 771, 7, 86, 2, 2, 771, 772, 7, 113, 2, 2, 772, 156, 3, 2, 2, 2, 773, 774, 7, 116, 2, 2, 774, 775, 7, 103, 2, 2, 775, 776, 7, 111, 2, 2, 776, 777, 7, 113, 2, 2, 777, 778, 7, 120, 2, 2, 778, 779, 7, 103, 2, 2, 779, 780, 7, 67, 2, 2, 780, 781, 7, 118, 2, 2, 781, 158, 3, 2, 2, 2, 782, 783, 7, 117, 2, 2, 783, 784, 7, 107, 2, 2, 784, 785, 7, 112, 2, 2, 785, 786, 7, 105, 2, 2, 786, 787, 7, 110, 2, 2, 787, 788, 7, 103, 2, 2, 788, 789, 7, 118, 2, 2, 789, 790, 7, 113, 2, 2, 790, 791, 7, 112, 2, 2, 791, 792, 7, 85, 2, 2, 792, 793, 7, 103, 2, 2, 793, 794, 7, 118, 2, 2, 794, 160, 3, 2, 2, 2, 795, 796, 7, 117, 2, 2, 796, 797, 7, 107, 2, 2, 797, 798, 7, 124, 2, 2, 798, 799, 7, 103, 2, 2, 799, 162, 3, 2, 2, 2, 800, 801, 7, 117, 2, 2, 801, 802, 7, 114, 2, 2, 802, 803, 7, 110, 2, 2, 803, 804, 7, 107, 2, 2, 804, 805, 7, 118, 2, 2, 805, 164, 3, 2, 2, 2, 806, 807, 7, 118, 2, 2, 807, 808, 7, 113, 2, 2, 808, 809, 7, 114, 2, 2, 809, 810, 7, 68, 2, 2, 810, 811, 7, 99, 2, 2, 811, 812, 7, 101, 2, 2, 812, 813, 7, 109, 2, 2, 813, 166, 3, 2, 2, 2, 814, 815, 7, 118, 2, 2, 815, 816, 7, 113, 2, 2, 816, 817, 7, 114, 2, 2, 817, 818, 7, 72, 2, 2, 818, 819, 7, 116, 2, 2, 819, 820, 7, 113, 2, 2, 820, 821, 7, 112, 2, 2, 821, 822, 7, 118, 2, 2, 822, 168, 3, 2, 2, 2, 823, 824, 7, 119, 2, 2, 824, 825, 7, 114, 2, 2, 825, 826, 7, 102, 2, 2, 826, 827, 7, 99, 2, 2, 827, 828, 7, 118, 2, 2, 828, 829, 7, 103, 2, 2, 829, 170, 3, 2, 2, 2, 830, 831, 7, 119, 2, 2, 831, 832, 7, 112, 2, 2, 832, 833, 7, 107, 2, 2, 833, 834, 7, 104, 2, 2, 834, 835, 7, 113, 2, 2, 835, 836, 7, 116, 2, 2, 836, 837, 7, 111, 2, 2, 837, 838, 7, 80, 2, 2, 838, 839, 7, 99, 2, 2, 839, 840, 7, 118, 2, 2, 840, 172, 3, 2, 2, 2, 841, 842, 7, 104, 2, 2, 842, 843, 7, 110, 2, 2, 843, 844, 7, 107, 2, 2, 844, 845, 7, 114, 2, 2, 845, 174, 3, 2, 2, 2, 846, 847, 7, 119, 2, 2, 847, 848, 7, 112, 2, 2, 848, 849, 7, 107, 2, 2, 849, 850, 7, 104, 2, 2, 850, 851, 7, 113, 2, 2, 851, 852, 7, 116, 2, 2, 852, 853, 7, 111, 2, 2, 853, 854, 7, 72, 2, 2, 854, 855, 7, 110, 2, 2, 855, 856, 7, 113, 2, 2, 856, 857, 7, 99, 2, 2, 857, 858, 7, 118, 2, 2, 858, 176, 3, 2, 2, 2, 859, 860, 7, 119, 2, 2, 860, 861, 7, 112, 2, 2, 861, 862, 7, 107, 2, 2, 862, 863, 7, 104, 2, 2, 863, 864, 7, 113, 2, 2, 864, 865, 7, 116, 2, 2, 865, 866, 7, 111, 2, 2, 866, 867, 7, 82, 2, 2, 867, 868, 7, 103, 2, 2, 868, 869, 7, 116, 2, 2, 869, 870, 7, 111, 2, 2, 870, 178, 3, 2, 2, 2, 871, 872, 7, 117, 2, 2, 872, 873, 7, 48, 2, 2, 873, 874, 7, 118, 2, 2, 874, 875, 7, 48, 2, 2, 875, 180, 3, 2, 2, 2, 876, 877, 7, 38, 2, 2, 877, 182, 3, 2, 2, 2, 878, 879, 7, 47, 2, 2, 879, 880, 7, 64, 2, 2, 880, 184, 3, 2, 2, 2, 881, 882, 7, 37, 2, 2, 882, 186, 3, 2, 2, 2, 883, 884, 7, 66, 2, 2, 884, 188, 3, 2, 2, 2, 885, 886, 7, 69, 2, 2, 886, 887, 7, 113, 2, 2, 887, 888, 7, 119, 2, 2, 888, 889, 7, 112, 2, 2, 889, 890, 7, 118, 2, 2, 890, 190, 3, 2, 2, 2, 891, 892, 7, 87, 2, 2, 892, 192, 3, 2, 2, 2, 893, 894, 7, 96, 2, 2, 894, 194, 3, 2, 2, 2, 895, 896, 7, 94, 2, 2, 896, 196, 3, 2, 2, 2, 897, 899, 9, 5, 2, 2, 898, 897, 3, 2, 2, 2, 899, 900, 3, 2, 2, 2, 900, 898, 3, 2, 2, 2, 900, 901, 3, 2, 2, 2, 901, 198, 3, 2, 2, 2, 902, 904, 9, 5, 2, 2, 903, 902, 3, 2, 2, 2, 904, 905, 3, 2, 2, 2, 905, 903, 3, 2, 2, 2, 905, 906, 3, 2, 2, 2, 906, 907, 3, 2, 2, 2, 907, 909, 5, 269, 135, 2, 908, 910, 9, 5, 2, 2, 909, 908, 3, 2, 2, 2, 910, 911, 3, 2, 2, 2, 911, 909, 3, 2, 2, 2, 911, 912, 3, 2, 2, 2, 912, 200, 3, 2, 2, 2, 913, 914, 7, 118, 2, 2, 914, 915, 7, 116, 2, 2, 915, 916, 7, 119, 2, 2, 916, 923, 7, 103, 2, 2, 917, 918, 7, 104, 2, 2, 918, 919, 7, 99, 2, 2, 919, 920, 7, 110, 2, 2, 920, 921, 7, 117, 2, 2, 921, 923, 7, 103, 2, 2, 922, 913, 3, 2, 2, 2, 922, 917, 3, 2, 2, 2, 923, 202, 3, 2, 2, 2, 924, 929, 5, 9, 5, 2, 925, 928, 5, 11, 6, 2, 926, 928, 5, 9, 5, 2, 927, 925, 3, 2, 2, 2, 927, 926, 3, 2, 2, 2, 928, 931, 3, 2, 2, 2, 929, 927, 3, 2, 2, 2, 929, 930, 3, 2, 2, 2, 930, 204, 3, 2, 2, 2, 931, 929, 3, 2, 2, 2, 932, 933, 7, 45, 2, 2, 933, 934, 7, 45, 2, 2, 934, 206, 3, 2, 2, 2, 935, 936, 7, 47, 2, 2, 936, 937, 7, 47, 2, 2, 937, 208, 3, 2, 2, 2, 938, 939, 7, 40, 2, 2, 939, 210, 3, 2, 2, 2, 940, 941, 7, 45, 2, 2, 941, 942, 7, 39, 2, 2, 942, 212, 3, 2, 2, 2, 943, 944, 7, 47, 2, 2, 944, 945, 7, 39, 2, 2, 945, 214, 3, 2, 2, 2, 946, 947, 7, 45, 2, 2, 947, 948, 7, 45, 2, 2, 948, 949, 7, 39, 2, 2, 949, 216, 3, 2, 2, 2, 950, 951, 7, 47, 2, 2, 951, 952, 7, 47, 2, 2, 952, 953, 7, 39, 2, 2, 953, 218, 3, 2, 2, 2, 954, 955, 7, 62, 2, 2, 955, 220, 3, 2, 2, 2, 956, 957, 7, 64, 2, 2, 957, 222, 3, 2, 2, 2, 958, 959, 7, 62, 2, 2, 959, 960, 7, 63, 2, 2, 960, 224, 3, 2, 2, 2, 961, 962, 7, 64, 2, 2, 962, 963, 7, 63, 2, 2, 963, 226, 3, 2, 2, 2, 964, 965, 7, 63, 2, 2, 965, 966, 7, 63, 2, 2, 966, 228, 3, 2, 2, 2, 967, 968, 7, 35, 2, 2, 968, 969, 7, 63, 2, 2, 969, 230, 3, 2, 2, 2, 970, 992, 7, 63, 2, 2, 971, 972, 7, 45, 2, 2, 972, 992, 7, 63, 2, 2, 973, 974, 7, 47, 2, 2, 974, 992, 7, 63, 2, 2, 975, 976, 7, 44, 2, 2, 976, 992, 7, 63, 2, 2, 977, 978, 7, 49, 2, 2, 978, 992, 7, 63, 2, 2, 979, 980, 7, 39, 2, 2, 980, 992, 7, 63, 2, 2, 981, 982, 7, 62, 2, 2, 982, 983, 7, 62, 2, 2, 983, 992, 7, 63, 2, 2, 984, 985, 7, 64, 2, 2, 985, 986, 7, 64, 2, 2, 986, 992, 7, 63, 2, 2, 987, 988, 7, 40, 2, 2, 988, 992, 7, 63, 2, 2, 989, 990, 7, 126, 2, 2, 990, 992, 7, 63, 2, 2, 991, 970, 3, 2, 2, 2, 991, 971, 3, 2, 2, 2, 991, 973, 3, 2, 2, 2, 991, 975, 3, 2, 2, 2, 991, 977, 3, 2, 2, 2, 991, 979, 3, 2, 2, 2, 991, 981, 3, 2, 2, 2, 991, 984, 3, 2, 2, 2, 991, 987, 3, 2, 2, 2, 991, 989, 3, 2, 2, 2, 992, 232, 3, 2, 2, 2, 993, 994, 7, 47, 2, 2, 994, 234, 3, 2, 2, 2, 995, 996, 7, 45, 2, 2, 996, 236, 3, 2, 2, 2, 997, 998, 7, 44, 2, 2, 998, 238, 3, 2, 2, 2, 999, 1000, 7, 49, 2, 2, 1000, 240, 3, 2, 2, 2, 1001, 1002, 7, 39, 2, 2, 1002, 242, 3, 2, 2, 2, 1003, 1004, 7, 42, 2, 2, 1004, 244, 3, 2, 2, 2, 1005, 1006, 7, 43, 2, 2, 1006, 246, 3, 2, 2, 2, 1007, 1008, 7, 62, 2, 2, 1008, 1009, 7, 62, 2, 2, 1009, 248, 3, 2, 2, 2, 1010, 1011, 7, 64, 2, 2, 1011, 1012, 7, 64, 2, 2, 1012, 250, 3, 2, 2, 2, 1013, 1014, 7, 126, 2, 2, 1014, 1015, 7, 126, 2, 2, 1015, 252, 3, 2, 2, 2, 1016, 1017, 7, 40, 2, 2, 1017, 1018, 7, 40, 2, 2, 1018, 254, 3, 2, 2, 2, 1019, 1020, 7, 35, 2, 2, 1020, 256, 3, 2, 2, 2, 1021, 1022, 7, 61, 2, 2, 1022, 258, 3, 2, 2, 2, 1023, 1024, 7, 60, 2, 2, 1024, 260, 3, 2, 2, 2, 1025, 1026, 7, 126, 2, 2, 1026, 262, 3, 2, 2, 2, 1027, 1028, 7, 125, 2, 2, 1028, 264, 3, 2, 2, 2, 1029, 1030, 7, 127, 2, 2, 1030, 266, 3, 2, 2, 2, 1031, 1032, 7, 46, 2, 2, 1032, 268, 3, 2, 2, 2, 1033, 1034, 7, 48, 2, 2, 1034, 270, 3, 2, 2, 2, 1035, 1036, 7, 93, 2, 2, 1036, 272, 3, 2, 2, 2, 1037, 1038, 7, 95, 2, 2, 1038, 274, 3, 2, 2, 2, 1039, 1040, 7, 36, 2, 2, 1040, 276, 3, 2, 2, 2, 1041, 1042, 7, 65, 2, 2, 1042, 278, 3, 2, 2, 2, 1043, 1047, 7, 36, 2, 2, 1044, 1046, 10, 7, 2, 2, 1045, 1044, 3, 2, 2, 2, 1046, 1049, 3, 2, 2, 2, 1047, 1045, 3, 2, 2, 2, 1047, 1048, 3, 2, 2, 2, 1048, 1050, 3, 2, 2, 2, 1049, 1047, 3, 2, 2, 2, 1050, 1051, 7, 36, 2, 2, 1051, 280, 3, 2, 2, 2, 14, 2, 284, 294, 308, 900, 905, 911, 922, 927, 929, 991, 1047, 3, 8, 2, 2] \ No newline at end of file diff --git a/src/main/java/grammar/alkLexer.java b/src/main/java/grammar/alkLexer.java index 12e58e87..e5a0d8d0 100644 --- a/src/main/java/grammar/alkLexer.java +++ b/src/main/java/grammar/alkLexer.java @@ -23,23 +23,23 @@ public class alkLexer extends Lexer { REQURIES=8, ENSURES=9, RESULT=10, IMPLIES=11, EQUIV=12, FORALL=13, EXISTS=14, QUANTIFIER_SEPARATOR=15, TO=16, IF=17, ELSE=18, WHILE=19, DO=20, FOR=21, FOREACH=22, IN=23, FROM=24, OUT=25, HAVOC=26, CHOOSE=27, UNIFORM=28, REPEAT=29, - RETURN=30, SUCCESS=31, UNTIL=32, FAILURE=33, CONTINUE=34, BREAK=35, EMPTYSET=36, - EMPTYLIST=37, EMPTYSTRUCTURE=38, MODIFIES=39, USES=40, INCLDUE=41, XOR=42, - ABS=43, ACOS=44, ASIN=45, ATAN=46, COS=47, LOG=48, PI=49, POW=50, SIN=51, - SQRT=52, TAN=53, LEN=54, ARRAY=55, SET=56, AT=57, BELONGSTO=58, DELETE=59, - EMPTY=60, END=61, FIRST=62, FLOAT=63, INSERT=64, INTEGER=65, BOOLEAN=66, - PRINT=67, POPBACK=68, POPFRONT=69, PUSHBACK=70, PUSHFRONT=71, REMOVE=72, - REMOVEALLEQTO=73, REMOVEAT=74, SINGLETONSET=75, SIZE=76, SPLIT=77, TOPBACK=78, - TOPFRONT=79, UPDATE=80, UNIFORMNAT=81, FLIP=82, UNIFORMFLOAT=83, UNIFORMPERM=84, - SOTHAT=85, SYM=86, ARROW=87, NUMSIGN=88, ANNO=89, COUNT=90, UNION=91, - INTERSECT=92, SUBTRACT=93, INT=94, DOUBLE=95, BOOL=96, ID=97, PLUSPLUS=98, - MINUSMINUS=99, BITWISE_AND=100, PLUSMOD=101, MINUSMOD=102, PLUSPLUSMOD=103, - MINUSMINUSMOD=104, LOWER=105, GREATER=106, LOWEREQ=107, GREATEREQ=108, - ISEQUAL=109, NOTEQUAL=110, ASSIGNMENT_OPERATOR=111, MINUS=112, PLUS=113, - MUL=114, DIV=115, MOD=116, LPAR=117, RPAR=118, LEFTSHIFT=119, RIGHTSHIFT=120, - OR=121, AND=122, NOT=123, SEMICOLON=124, DPOINT=125, VBAR=126, LCB=127, - RCB=128, COMMA=129, POINT=130, LBRA=131, RBRA=132, QUOTE=133, QUESTION=134, - STRING=135; + RETURN=30, SUCCESS=31, UNTIL=32, FAILURE=33, CONTINUE=34, BREAK=35, EMPTYMAP=36, + EMPTYSET=37, EMPTYLIST=38, EMPTYSTRUCTURE=39, MODIFIES=40, USES=41, INCLDUE=42, + XOR=43, ABS=44, ACOS=45, ASIN=46, ATAN=47, COS=48, LOG=49, PI=50, POW=51, + SIN=52, SQRT=53, TAN=54, LEN=55, ARRAY=56, SET=57, AT=58, BELONGSTO=59, + DELETE=60, EMPTY=61, END=62, FIRST=63, FLOAT=64, INSERT=65, INTEGER=66, + BOOLEAN=67, PRINT=68, POPBACK=69, POPFRONT=70, PUSHBACK=71, PUSHFRONT=72, + REMOVE=73, REMOVEALLEQTO=74, REMOVEAT=75, SINGLETONSET=76, SIZE=77, SPLIT=78, + TOPBACK=79, TOPFRONT=80, UPDATE=81, UNIFORMNAT=82, FLIP=83, UNIFORMFLOAT=84, + UNIFORMPERM=85, SOTHAT=86, SYM=87, ARROW=88, NUMSIGN=89, ANNO=90, COUNT=91, + UNION=92, INTERSECT=93, SUBTRACT=94, INT=95, DOUBLE=96, BOOL=97, ID=98, + PLUSPLUS=99, MINUSMINUS=100, BITWISE_AND=101, PLUSMOD=102, MINUSMOD=103, + PLUSPLUSMOD=104, MINUSMINUSMOD=105, LOWER=106, GREATER=107, LOWEREQ=108, + GREATEREQ=109, ISEQUAL=110, NOTEQUAL=111, ASSIGNMENT_OPERATOR=112, MINUS=113, + PLUS=114, MUL=115, DIV=116, MOD=117, LPAR=118, RPAR=119, LEFTSHIFT=120, + RIGHTSHIFT=121, OR=122, AND=123, NOT=124, SEMICOLON=125, DPOINT=126, VBAR=127, + LCB=128, RCB=129, COMMA=130, POINT=131, LBRA=132, RBRA=133, QUOTE=134, + QUESTION=135, STRING=136; public static String[] channelNames = { "DEFAULT_TOKEN_CHANNEL", "HIDDEN" }; @@ -54,15 +54,15 @@ public class alkLexer extends Lexer { "IMPLIES", "EQUIV", "FORALL", "EXISTS", "QUANTIFIER_SEPARATOR", "TO", "IF", "ELSE", "WHILE", "DO", "FOR", "FOREACH", "IN", "FROM", "OUT", "HAVOC", "CHOOSE", "UNIFORM", "REPEAT", "RETURN", "SUCCESS", "UNTIL", "FAILURE", - "CONTINUE", "BREAK", "EMPTYSET", "EMPTYLIST", "EMPTYSTRUCTURE", "MODIFIES", - "USES", "INCLDUE", "XOR", "ABS", "ACOS", "ASIN", "ATAN", "COS", "LOG", - "PI", "POW", "SIN", "SQRT", "TAN", "LEN", "ARRAY", "SET", "AT", "BELONGSTO", - "DELETE", "EMPTY", "END", "FIRST", "FLOAT", "INSERT", "INTEGER", "BOOLEAN", - "PRINT", "POPBACK", "POPFRONT", "PUSHBACK", "PUSHFRONT", "REMOVE", "REMOVEALLEQTO", - "REMOVEAT", "SINGLETONSET", "SIZE", "SPLIT", "TOPBACK", "TOPFRONT", "UPDATE", - "UNIFORMNAT", "FLIP", "UNIFORMFLOAT", "UNIFORMPERM", "SOTHAT", "SYM", - "ARROW", "NUMSIGN", "ANNO", "COUNT", "UNION", "INTERSECT", "SUBTRACT", - "INT", "DOUBLE", "BOOL", "ID", "PLUSPLUS", "MINUSMINUS", "BITWISE_AND", + "CONTINUE", "BREAK", "EMPTYMAP", "EMPTYSET", "EMPTYLIST", "EMPTYSTRUCTURE", + "MODIFIES", "USES", "INCLDUE", "XOR", "ABS", "ACOS", "ASIN", "ATAN", "COS", + "LOG", "PI", "POW", "SIN", "SQRT", "TAN", "LEN", "ARRAY", "SET", "AT", + "BELONGSTO", "DELETE", "EMPTY", "END", "FIRST", "FLOAT", "INSERT", "INTEGER", + "BOOLEAN", "PRINT", "POPBACK", "POPFRONT", "PUSHBACK", "PUSHFRONT", "REMOVE", + "REMOVEALLEQTO", "REMOVEAT", "SINGLETONSET", "SIZE", "SPLIT", "TOPBACK", + "TOPFRONT", "UPDATE", "UNIFORMNAT", "FLIP", "UNIFORMFLOAT", "UNIFORMPERM", + "SOTHAT", "SYM", "ARROW", "NUMSIGN", "ANNO", "COUNT", "UNION", "INTERSECT", + "SUBTRACT", "INT", "DOUBLE", "BOOL", "ID", "PLUSPLUS", "MINUSMINUS", "BITWISE_AND", "PLUSMOD", "MINUSMOD", "PLUSPLUSMOD", "MINUSMINUSMOD", "LOWER", "GREATER", "LOWEREQ", "GREATEREQ", "ISEQUAL", "NOTEQUAL", "ASSIGNMENT_OPERATOR", "MINUS", "PLUS", "MUL", "DIV", "MOD", "LPAR", "RPAR", "LEFTSHIFT", "RIGHTSHIFT", @@ -76,12 +76,12 @@ public class alkLexer extends Lexer { "'exists'", "'::'", "'|->'", "'if'", "'else'", "'while'", "'do'", "'for'", "'foreach'", "'in'", "'from'", "'out'", "'havoc'", "'choose'", "'uniform'", "'repeat'", "'return'", "'success'", "'until'", "'failure'", "'continue'", - "'break'", "'emptySet'", "'emptyList'", "'emptyStructure'", "'modifies'", - "'uses'", "'include'", "'xor'", "'abs'", "'acos'", "'asin'", "'atan'", - "'cos'", "'log'", "'pi'", "'pow'", "'sin'", "'sqrt'", "'tan'", "'len'", - "'array'", "'set'", "'at'", "'belongsTo'", "'delete'", "'empty'", "'end'", - "'first'", "'float'", "'insert'", "'int'", "'boolean'", "'print'", "'popBack'", - "'popFront'", "'pushBack'", "'pushFront'", "'remove'", "'removeAllEqTo'", + "'break'", "'emptyMap'", "'emptySet'", "'emptyList'", "'emptyStructure'", + "'modifies'", "'uses'", "'include'", "'xor'", "'abs'", "'acos'", "'asin'", + "'atan'", "'cos'", "'log'", "'pi'", "'pow'", "'sin'", "'sqrt'", "'tan'", + "'len'", "'array'", "'set'", "'at'", "'belongsTo'", "'delete'", "'empty'", + "'end'", "'first'", "'float'", "'insert'", "'int'", "'boolean'", "'print'", + "'popBack'", "'popFront'", "'pushBack'", "'pushFront'", "'remove'", "'removeAllEqTo'", "'removeAt'", "'singletonSet'", "'size'", "'split'", "'topBack'", "'topFront'", "'update'", "'uniformNat'", "'flip'", "'uniformFloat'", "'uniformPerm'", "'s.t.'", "'$'", "'->'", "'#'", "'@'", "'Count'", "'U'", "'^'", "'\\'", @@ -96,21 +96,21 @@ public class alkLexer extends Lexer { "INVARIANT", "REQURIES", "ENSURES", "RESULT", "IMPLIES", "EQUIV", "FORALL", "EXISTS", "QUANTIFIER_SEPARATOR", "TO", "IF", "ELSE", "WHILE", "DO", "FOR", "FOREACH", "IN", "FROM", "OUT", "HAVOC", "CHOOSE", "UNIFORM", "REPEAT", - "RETURN", "SUCCESS", "UNTIL", "FAILURE", "CONTINUE", "BREAK", "EMPTYSET", - "EMPTYLIST", "EMPTYSTRUCTURE", "MODIFIES", "USES", "INCLDUE", "XOR", "ABS", - "ACOS", "ASIN", "ATAN", "COS", "LOG", "PI", "POW", "SIN", "SQRT", "TAN", - "LEN", "ARRAY", "SET", "AT", "BELONGSTO", "DELETE", "EMPTY", "END", "FIRST", - "FLOAT", "INSERT", "INTEGER", "BOOLEAN", "PRINT", "POPBACK", "POPFRONT", - "PUSHBACK", "PUSHFRONT", "REMOVE", "REMOVEALLEQTO", "REMOVEAT", "SINGLETONSET", - "SIZE", "SPLIT", "TOPBACK", "TOPFRONT", "UPDATE", "UNIFORMNAT", "FLIP", - "UNIFORMFLOAT", "UNIFORMPERM", "SOTHAT", "SYM", "ARROW", "NUMSIGN", "ANNO", - "COUNT", "UNION", "INTERSECT", "SUBTRACT", "INT", "DOUBLE", "BOOL", "ID", - "PLUSPLUS", "MINUSMINUS", "BITWISE_AND", "PLUSMOD", "MINUSMOD", "PLUSPLUSMOD", - "MINUSMINUSMOD", "LOWER", "GREATER", "LOWEREQ", "GREATEREQ", "ISEQUAL", - "NOTEQUAL", "ASSIGNMENT_OPERATOR", "MINUS", "PLUS", "MUL", "DIV", "MOD", - "LPAR", "RPAR", "LEFTSHIFT", "RIGHTSHIFT", "OR", "AND", "NOT", "SEMICOLON", - "DPOINT", "VBAR", "LCB", "RCB", "COMMA", "POINT", "LBRA", "RBRA", "QUOTE", - "QUESTION", "STRING" + "RETURN", "SUCCESS", "UNTIL", "FAILURE", "CONTINUE", "BREAK", "EMPTYMAP", + "EMPTYSET", "EMPTYLIST", "EMPTYSTRUCTURE", "MODIFIES", "USES", "INCLDUE", + "XOR", "ABS", "ACOS", "ASIN", "ATAN", "COS", "LOG", "PI", "POW", "SIN", + "SQRT", "TAN", "LEN", "ARRAY", "SET", "AT", "BELONGSTO", "DELETE", "EMPTY", + "END", "FIRST", "FLOAT", "INSERT", "INTEGER", "BOOLEAN", "PRINT", "POPBACK", + "POPFRONT", "PUSHBACK", "PUSHFRONT", "REMOVE", "REMOVEALLEQTO", "REMOVEAT", + "SINGLETONSET", "SIZE", "SPLIT", "TOPBACK", "TOPFRONT", "UPDATE", "UNIFORMNAT", + "FLIP", "UNIFORMFLOAT", "UNIFORMPERM", "SOTHAT", "SYM", "ARROW", "NUMSIGN", + "ANNO", "COUNT", "UNION", "INTERSECT", "SUBTRACT", "INT", "DOUBLE", "BOOL", + "ID", "PLUSPLUS", "MINUSMINUS", "BITWISE_AND", "PLUSMOD", "MINUSMOD", + "PLUSPLUSMOD", "MINUSMINUSMOD", "LOWER", "GREATER", "LOWEREQ", "GREATEREQ", + "ISEQUAL", "NOTEQUAL", "ASSIGNMENT_OPERATOR", "MINUS", "PLUS", "MUL", + "DIV", "MOD", "LPAR", "RPAR", "LEFTSHIFT", "RIGHTSHIFT", "OR", "AND", + "NOT", "SEMICOLON", "DPOINT", "VBAR", "LCB", "RCB", "COMMA", "POINT", + "LBRA", "RBRA", "QUOTE", "QUESTION", "STRING" }; public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); @@ -170,7 +170,7 @@ public alkLexer(CharStream input) { public ATN getATN() { return _ATN; } public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0089\u0411\b\1\4"+ + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u008a\u041c\b\1\4"+ "\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n"+ "\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"+ "\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"+ @@ -186,62 +186,63 @@ public alkLexer(CharStream input) { "\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t"+ "\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084"+ "\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089"+ - "\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\3\2\6\2\u0119\n\2\r\2\16\2\u011a"+ - "\3\2\3\2\3\3\3\3\3\3\3\3\7\3\u0123\n\3\f\3\16\3\u0126\13\3\3\3\3\3\3\3"+ - "\3\3\3\3\3\4\3\4\3\4\3\4\7\4\u0131\n\4\f\4\16\4\u0134\13\4\3\4\3\4\3\5"+ - "\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3"+ - "\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3"+ - "\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3"+ - "\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3"+ - "\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3"+ - "\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3"+ - "\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3"+ - "\30\3\30\3\30\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3"+ - "\32\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\36\3"+ - "\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3"+ - " \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3"+ - "#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3"+ - "&\3&\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ - ")\3)\3)\3)\3)\3)\3)\3)\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3"+ - "*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3"+ - "-\3.\3.\3.\3.\3/\3/\3/\3/\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61"+ - "\3\61\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64"+ - "\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\38\38\38\38\3"+ - "8\39\39\39\39\3:\3:\3:\3:\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3=\3=\3=\3>\3"+ - ">\3>\3>\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3@\3A\3"+ - "A\3A\3A\3B\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3"+ - "E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3"+ - "H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3"+ - "K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3"+ - "M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3"+ - "O\3O\3O\3O\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3R\3R\3"+ - "S\3S\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3"+ - "U\3U\3U\3U\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3X\3"+ - "X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3[\3[\3[\3\\\3\\"+ - "\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3`\3`\3a\3a\3b\6b\u0378\nb\rb\16b\u0379"+ - "\3c\6c\u037d\nc\rc\16c\u037e\3c\3c\6c\u0383\nc\rc\16c\u0384\3d\3d\3d\3"+ - "d\3d\3d\3d\3d\3d\5d\u0390\nd\3e\3e\3e\7e\u0395\ne\fe\16e\u0398\13e\3f"+ - "\3f\3f\3g\3g\3g\3h\3h\3i\3i\3i\3j\3j\3j\3k\3k\3k\3k\3l\3l\3l\3l\3m\3m"+ - "\3n\3n\3o\3o\3o\3p\3p\3p\3q\3q\3q\3r\3r\3r\3s\3s\3s\3s\3s\3s\3s\3s\3s"+ - "\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\5s\u03d5\ns\3t\3t\3u\3u\3v\3v\3w"+ - "\3w\3x\3x\3y\3y\3z\3z\3{\3{\3{\3|\3|\3|\3}\3}\3}\3~\3~\3~\3\177\3\177"+ - "\3\u0080\3\u0080\3\u0081\3\u0081\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084"+ - "\3\u0084\3\u0085\3\u0085\3\u0086\3\u0086\3\u0087\3\u0087\3\u0088\3\u0088"+ - "\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b\3\u008b\7\u008b\u040b\n\u008b"+ - "\f\u008b\16\u008b\u040e\13\u008b\3\u008b\3\u008b\3\u0124\2\u008c\3\3\5"+ - "\4\7\5\t\2\13\2\r\2\17\6\21\7\23\b\25\t\27\n\31\13\33\f\35\r\37\16!\17"+ - "#\20%\21\'\22)\23+\24-\25/\26\61\27\63\30\65\31\67\329\33;\34=\35?\36"+ - "A\37C E!G\"I#K$M%O&Q\'S(U)W*Y+[,]-_.a/c\60e\61g\62i\63k\64m\65o\66q\67"+ - "s8u9w:y;{<}=\177>\u0081?\u0083@\u0085A\u0087B\u0089C\u008bD\u008dE\u008f"+ - "F\u0091G\u0093H\u0095I\u0097J\u0099K\u009bL\u009dM\u009fN\u00a1O\u00a3"+ - "P\u00a5Q\u00a7R\u00a9S\u00abT\u00adU\u00afV\u00b1W\u00b3X\u00b5Y\u00b7"+ - "Z\u00b9[\u00bb\\\u00bd]\u00bf^\u00c1_\u00c3`\u00c5a\u00c7b\u00c9c\u00cb"+ - "d\u00cde\u00cff\u00d1g\u00d3h\u00d5i\u00d7j\u00d9k\u00dbl\u00ddm\u00df"+ - "n\u00e1o\u00e3p\u00e5q\u00e7r\u00e9s\u00ebt\u00edu\u00efv\u00f1w\u00f3"+ - "x\u00f5y\u00f7z\u00f9{\u00fb|\u00fd}\u00ff~\u0101\177\u0103\u0080\u0105"+ - "\u0081\u0107\u0082\u0109\u0083\u010b\u0084\u010d\u0085\u010f\u0086\u0111"+ - "\u0087\u0113\u0088\u0115\u0089\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17"+ - "\5\2C\\aac|\3\2\62;\3\2\63;\5\2\f\f\17\17$$\2\u0420\2\3\3\2\2\2\2\5\3"+ + "\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\3\2\6\2\u011b"+ + "\n\2\r\2\16\2\u011c\3\2\3\2\3\3\3\3\3\3\3\3\7\3\u0125\n\3\f\3\16\3\u0128"+ + "\13\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\7\4\u0133\n\4\f\4\16\4\u0136"+ + "\13\4\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\t"+ + "\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13"+ + "\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3"+ + "\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3"+ + "\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3"+ + "\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3"+ + "\24\3\24\3\24\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3"+ + "\27\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3"+ + "\32\3\32\3\32\3\32\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3"+ + "\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3"+ + "\37\3 \3 \3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3"+ + "\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%"+ + "\3%\3&\3&\3&\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3("+ + "\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*"+ + "\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,"+ + "\3,\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3\60\3\60\3\60"+ + "\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63"+ + "\3\63\3\63\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\67"+ + "\3\67\3\67\3\67\38\38\38\38\39\39\39\39\39\3:\3:\3:\3:\3;\3;\3;\3;\3<"+ + "\3<\3<\3<\3<\3<\3=\3=\3=\3=\3>\3>\3>\3?\3?\3?\3?\3?\3?\3?\3?\3?\3?\3@"+ + "\3@\3@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3C\3C\3C\3C\3C\3C\3D"+ + "\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3G\3G\3G\3G\3G\3G\3G"+ + "\3G\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\3J\3J"+ + "\3J\3K\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L\3L\3L\3L\3M\3M\3M"+ + "\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O"+ + "\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3R"+ + "\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3T\3U"+ + "\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3X"+ + "\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y"+ + "\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3\\\3\\\3\\\3]\3]\3^\3^\3_\3_\3_\3_\3_\3_\3`"+ + "\3`\3a\3a\3b\3b\3c\6c\u0383\nc\rc\16c\u0384\3d\6d\u0388\nd\rd\16d\u0389"+ + "\3d\3d\6d\u038e\nd\rd\16d\u038f\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e\u039b\n"+ + "e\3f\3f\3f\7f\u03a0\nf\ff\16f\u03a3\13f\3g\3g\3g\3h\3h\3h\3i\3i\3j\3j"+ + "\3j\3k\3k\3k\3l\3l\3l\3l\3m\3m\3m\3m\3n\3n\3o\3o\3p\3p\3p\3q\3q\3q\3r"+ + "\3r\3r\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t\3t"+ + "\3t\3t\3t\5t\u03e0\nt\3u\3u\3v\3v\3w\3w\3x\3x\3y\3y\3z\3z\3{\3{\3|\3|"+ + "\3|\3}\3}\3}\3~\3~\3~\3\177\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081"+ + "\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086"+ + "\3\u0086\3\u0087\3\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a"+ + "\3\u008b\3\u008b\3\u008c\3\u008c\7\u008c\u0416\n\u008c\f\u008c\16\u008c"+ + "\u0419\13\u008c\3\u008c\3\u008c\3\u0126\2\u008d\3\3\5\4\7\5\t\2\13\2\r"+ + "\2\17\6\21\7\23\b\25\t\27\n\31\13\33\f\35\r\37\16!\17#\20%\21\'\22)\23"+ + "+\24-\25/\26\61\27\63\30\65\31\67\329\33;\34=\35?\36A\37C E!G\"I#K$M%"+ + "O&Q\'S(U)W*Y+[,]-_.a/c\60e\61g\62i\63k\64m\65o\66q\67s8u9w:y;{<}=\177"+ + ">\u0081?\u0083@\u0085A\u0087B\u0089C\u008bD\u008dE\u008fF\u0091G\u0093"+ + "H\u0095I\u0097J\u0099K\u009bL\u009dM\u009fN\u00a1O\u00a3P\u00a5Q\u00a7"+ + "R\u00a9S\u00abT\u00adU\u00afV\u00b1W\u00b3X\u00b5Y\u00b7Z\u00b9[\u00bb"+ + "\\\u00bd]\u00bf^\u00c1_\u00c3`\u00c5a\u00c7b\u00c9c\u00cbd\u00cde\u00cf"+ + "f\u00d1g\u00d3h\u00d5i\u00d7j\u00d9k\u00dbl\u00ddm\u00dfn\u00e1o\u00e3"+ + "p\u00e5q\u00e7r\u00e9s\u00ebt\u00edu\u00efv\u00f1w\u00f3x\u00f5y\u00f7"+ + "z\u00f9{\u00fb|\u00fd}\u00ff~\u0101\177\u0103\u0080\u0105\u0081\u0107"+ + "\u0082\u0109\u0083\u010b\u0084\u010d\u0085\u010f\u0086\u0111\u0087\u0113"+ + "\u0088\u0115\u0089\u0117\u008a\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17"+ + "\5\2C\\aac|\3\2\62;\3\2\63;\5\2\f\f\17\17$$\2\u042b\2\3\3\2\2\2\2\5\3"+ "\2\2\2\2\7\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2"+ "\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3"+ "\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2"+ @@ -268,252 +269,255 @@ public alkLexer(CharStream input) { "\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff\3\2\2\2\2\u0101"+ "\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2"+ "\2\2\u010b\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2\2\2\u0113"+ - "\3\2\2\2\2\u0115\3\2\2\2\3\u0118\3\2\2\2\5\u011e\3\2\2\2\7\u012c\3\2\2"+ - "\2\t\u0137\3\2\2\2\13\u0139\3\2\2\2\r\u013b\3\2\2\2\17\u013d\3\2\2\2\21"+ - "\u0144\3\2\2\2\23\u014b\3\2\2\2\25\u0154\3\2\2\2\27\u015e\3\2\2\2\31\u0167"+ - "\3\2\2\2\33\u016f\3\2\2\2\35\u0176\3\2\2\2\37\u017a\3\2\2\2!\u017f\3\2"+ - "\2\2#\u0186\3\2\2\2%\u018d\3\2\2\2\'\u0190\3\2\2\2)\u0194\3\2\2\2+\u0197"+ - "\3\2\2\2-\u019c\3\2\2\2/\u01a2\3\2\2\2\61\u01a5\3\2\2\2\63\u01a9\3\2\2"+ - "\2\65\u01b1\3\2\2\2\67\u01b4\3\2\2\29\u01b9\3\2\2\2;\u01bd\3\2\2\2=\u01c3"+ - "\3\2\2\2?\u01ca\3\2\2\2A\u01d2\3\2\2\2C\u01d9\3\2\2\2E\u01e0\3\2\2\2G"+ - "\u01e8\3\2\2\2I\u01ee\3\2\2\2K\u01f6\3\2\2\2M\u01ff\3\2\2\2O\u0205\3\2"+ - "\2\2Q\u020e\3\2\2\2S\u0218\3\2\2\2U\u0227\3\2\2\2W\u0230\3\2\2\2Y\u0235"+ - "\3\2\2\2[\u023d\3\2\2\2]\u0241\3\2\2\2_\u0245\3\2\2\2a\u024a\3\2\2\2c"+ - "\u024f\3\2\2\2e\u0254\3\2\2\2g\u0258\3\2\2\2i\u025c\3\2\2\2k\u025f\3\2"+ - "\2\2m\u0263\3\2\2\2o\u0267\3\2\2\2q\u026c\3\2\2\2s\u0270\3\2\2\2u\u0274"+ - "\3\2\2\2w\u027a\3\2\2\2y\u027e\3\2\2\2{\u0281\3\2\2\2}\u028b\3\2\2\2\177"+ - "\u0292\3\2\2\2\u0081\u0298\3\2\2\2\u0083\u029c\3\2\2\2\u0085\u02a2\3\2"+ - "\2\2\u0087\u02a8\3\2\2\2\u0089\u02af\3\2\2\2\u008b\u02b3\3\2\2\2\u008d"+ - "\u02bb\3\2\2\2\u008f\u02c1\3\2\2\2\u0091\u02c9\3\2\2\2\u0093\u02d2\3\2"+ - "\2\2\u0095\u02db\3\2\2\2\u0097\u02e5\3\2\2\2\u0099\u02ec\3\2\2\2\u009b"+ - "\u02fa\3\2\2\2\u009d\u0303\3\2\2\2\u009f\u0310\3\2\2\2\u00a1\u0315\3\2"+ - "\2\2\u00a3\u031b\3\2\2\2\u00a5\u0323\3\2\2\2\u00a7\u032c\3\2\2\2\u00a9"+ - "\u0333\3\2\2\2\u00ab\u033e\3\2\2\2\u00ad\u0343\3\2\2\2\u00af\u0350\3\2"+ - "\2\2\u00b1\u035c\3\2\2\2\u00b3\u0361\3\2\2\2\u00b5\u0363\3\2\2\2\u00b7"+ - "\u0366\3\2\2\2\u00b9\u0368\3\2\2\2\u00bb\u036a\3\2\2\2\u00bd\u0370\3\2"+ - "\2\2\u00bf\u0372\3\2\2\2\u00c1\u0374\3\2\2\2\u00c3\u0377\3\2\2\2\u00c5"+ - "\u037c\3\2\2\2\u00c7\u038f\3\2\2\2\u00c9\u0391\3\2\2\2\u00cb\u0399\3\2"+ - "\2\2\u00cd\u039c\3\2\2\2\u00cf\u039f\3\2\2\2\u00d1\u03a1\3\2\2\2\u00d3"+ - "\u03a4\3\2\2\2\u00d5\u03a7\3\2\2\2\u00d7\u03ab\3\2\2\2\u00d9\u03af\3\2"+ - "\2\2\u00db\u03b1\3\2\2\2\u00dd\u03b3\3\2\2\2\u00df\u03b6\3\2\2\2\u00e1"+ - "\u03b9\3\2\2\2\u00e3\u03bc\3\2\2\2\u00e5\u03d4\3\2\2\2\u00e7\u03d6\3\2"+ - "\2\2\u00e9\u03d8\3\2\2\2\u00eb\u03da\3\2\2\2\u00ed\u03dc\3\2\2\2\u00ef"+ - "\u03de\3\2\2\2\u00f1\u03e0\3\2\2\2\u00f3\u03e2\3\2\2\2\u00f5\u03e4\3\2"+ - "\2\2\u00f7\u03e7\3\2\2\2\u00f9\u03ea\3\2\2\2\u00fb\u03ed\3\2\2\2\u00fd"+ - "\u03f0\3\2\2\2\u00ff\u03f2\3\2\2\2\u0101\u03f4\3\2\2\2\u0103\u03f6\3\2"+ - "\2\2\u0105\u03f8\3\2\2\2\u0107\u03fa\3\2\2\2\u0109\u03fc\3\2\2\2\u010b"+ - "\u03fe\3\2\2\2\u010d\u0400\3\2\2\2\u010f\u0402\3\2\2\2\u0111\u0404\3\2"+ - "\2\2\u0113\u0406\3\2\2\2\u0115\u0408\3\2\2\2\u0117\u0119\t\2\2\2\u0118"+ - "\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u0118\3\2\2\2\u011a\u011b\3\2"+ - "\2\2\u011b\u011c\3\2\2\2\u011c\u011d\b\2\2\2\u011d\4\3\2\2\2\u011e\u011f"+ - "\7\61\2\2\u011f\u0120\7,\2\2\u0120\u0124\3\2\2\2\u0121\u0123\13\2\2\2"+ - "\u0122\u0121\3\2\2\2\u0123\u0126\3\2\2\2\u0124\u0125\3\2\2\2\u0124\u0122"+ - "\3\2\2\2\u0125\u0127\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0128\7,\2\2\u0128"+ - "\u0129\7\61\2\2\u0129\u012a\3\2\2\2\u012a\u012b\b\3\2\2\u012b\6\3\2\2"+ - "\2\u012c\u012d\7\61\2\2\u012d\u012e\7\61\2\2\u012e\u0132\3\2\2\2\u012f"+ - "\u0131\n\3\2\2\u0130\u012f\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130\3\2"+ - "\2\2\u0132\u0133\3\2\2\2\u0133\u0135\3\2\2\2\u0134\u0132\3\2\2\2\u0135"+ - "\u0136\b\4\2\2\u0136\b\3\2\2\2\u0137\u0138\t\4\2\2\u0138\n\3\2\2\2\u0139"+ - "\u013a\t\5\2\2\u013a\f\3\2\2\2\u013b\u013c\t\6\2\2\u013c\16\3\2\2\2\u013d"+ - "\u013e\7c\2\2\u013e\u013f\7u\2\2\u013f\u0140\7u\2\2\u0140\u0141\7g\2\2"+ - "\u0141\u0142\7t\2\2\u0142\u0143\7v\2\2\u0143\20\3\2\2\2\u0144\u0145\7"+ - "c\2\2\u0145\u0146\7u\2\2\u0146\u0147\7u\2\2\u0147\u0148\7w\2\2\u0148\u0149"+ - "\7o\2\2\u0149\u014a\7g\2\2\u014a\22\3\2\2\2\u014b\u014c\7u\2\2\u014c\u014d"+ - "\7{\2\2\u014d\u014e\7o\2\2\u014e\u014f\7d\2\2\u014f\u0150\7q\2\2\u0150"+ - "\u0151\7n\2\2\u0151\u0152\7k\2\2\u0152\u0153\7e\2\2\u0153\24\3\2\2\2\u0154"+ - "\u0155\7k\2\2\u0155\u0156\7p\2\2\u0156\u0157\7x\2\2\u0157\u0158\7c\2\2"+ - "\u0158\u0159\7t\2\2\u0159\u015a\7k\2\2\u015a\u015b\7c\2\2\u015b\u015c"+ - "\7p\2\2\u015c\u015d\7v\2\2\u015d\26\3\2\2\2\u015e\u015f\7t\2\2\u015f\u0160"+ - "\7g\2\2\u0160\u0161\7s\2\2\u0161\u0162\7w\2\2\u0162\u0163\7k\2\2\u0163"+ - "\u0164\7t\2\2\u0164\u0165\7g\2\2\u0165\u0166\7u\2\2\u0166\30\3\2\2\2\u0167"+ - "\u0168\7g\2\2\u0168\u0169\7p\2\2\u0169\u016a\7u\2\2\u016a\u016b\7w\2\2"+ - "\u016b\u016c\7t\2\2\u016c\u016d\7g\2\2\u016d\u016e\7u\2\2\u016e\32\3\2"+ - "\2\2\u016f\u0170\7t\2\2\u0170\u0171\7g\2\2\u0171\u0172\7u\2\2\u0172\u0173"+ - "\7w\2\2\u0173\u0174\7n\2\2\u0174\u0175\7v\2\2\u0175\34\3\2\2\2\u0176\u0177"+ - "\7?\2\2\u0177\u0178\7?\2\2\u0178\u0179\7@\2\2\u0179\36\3\2\2\2\u017a\u017b"+ - "\7>\2\2\u017b\u017c\7?\2\2\u017c\u017d\7?\2\2\u017d\u017e\7@\2\2\u017e"+ - " \3\2\2\2\u017f\u0180\7h\2\2\u0180\u0181\7q\2\2\u0181\u0182\7t\2\2\u0182"+ - "\u0183\7c\2\2\u0183\u0184\7n\2\2\u0184\u0185\7n\2\2\u0185\"\3\2\2\2\u0186"+ - "\u0187\7g\2\2\u0187\u0188\7z\2\2\u0188\u0189\7k\2\2\u0189\u018a\7u\2\2"+ - "\u018a\u018b\7v\2\2\u018b\u018c\7u\2\2\u018c$\3\2\2\2\u018d\u018e\7<\2"+ - "\2\u018e\u018f\7<\2\2\u018f&\3\2\2\2\u0190\u0191\7~\2\2\u0191\u0192\7"+ - "/\2\2\u0192\u0193\7@\2\2\u0193(\3\2\2\2\u0194\u0195\7k\2\2\u0195\u0196"+ - "\7h\2\2\u0196*\3\2\2\2\u0197\u0198\7g\2\2\u0198\u0199\7n\2\2\u0199\u019a"+ - "\7u\2\2\u019a\u019b\7g\2\2\u019b,\3\2\2\2\u019c\u019d\7y\2\2\u019d\u019e"+ - "\7j\2\2\u019e\u019f\7k\2\2\u019f\u01a0\7n\2\2\u01a0\u01a1\7g\2\2\u01a1"+ - ".\3\2\2\2\u01a2\u01a3\7f\2\2\u01a3\u01a4\7q\2\2\u01a4\60\3\2\2\2\u01a5"+ - "\u01a6\7h\2\2\u01a6\u01a7\7q\2\2\u01a7\u01a8\7t\2\2\u01a8\62\3\2\2\2\u01a9"+ - "\u01aa\7h\2\2\u01aa\u01ab\7q\2\2\u01ab\u01ac\7t\2\2\u01ac\u01ad\7g\2\2"+ - "\u01ad\u01ae\7c\2\2\u01ae\u01af\7e\2\2\u01af\u01b0\7j\2\2\u01b0\64\3\2"+ - "\2\2\u01b1\u01b2\7k\2\2\u01b2\u01b3\7p\2\2\u01b3\66\3\2\2\2\u01b4\u01b5"+ - "\7h\2\2\u01b5\u01b6\7t\2\2\u01b6\u01b7\7q\2\2\u01b7\u01b8\7o\2\2\u01b8"+ - "8\3\2\2\2\u01b9\u01ba\7q\2\2\u01ba\u01bb\7w\2\2\u01bb\u01bc\7v\2\2\u01bc"+ - ":\3\2\2\2\u01bd\u01be\7j\2\2\u01be\u01bf\7c\2\2\u01bf\u01c0\7x\2\2\u01c0"+ - "\u01c1\7q\2\2\u01c1\u01c2\7e\2\2\u01c2<\3\2\2\2\u01c3\u01c4\7e\2\2\u01c4"+ - "\u01c5\7j\2\2\u01c5\u01c6\7q\2\2\u01c6\u01c7\7q\2\2\u01c7\u01c8\7u\2\2"+ - "\u01c8\u01c9\7g\2\2\u01c9>\3\2\2\2\u01ca\u01cb\7w\2\2\u01cb\u01cc\7p\2"+ - "\2\u01cc\u01cd\7k\2\2\u01cd\u01ce\7h\2\2\u01ce\u01cf\7q\2\2\u01cf\u01d0"+ - "\7t\2\2\u01d0\u01d1\7o\2\2\u01d1@\3\2\2\2\u01d2\u01d3\7t\2\2\u01d3\u01d4"+ - "\7g\2\2\u01d4\u01d5\7r\2\2\u01d5\u01d6\7g\2\2\u01d6\u01d7\7c\2\2\u01d7"+ - "\u01d8\7v\2\2\u01d8B\3\2\2\2\u01d9\u01da\7t\2\2\u01da\u01db\7g\2\2\u01db"+ - "\u01dc\7v\2\2\u01dc\u01dd\7w\2\2\u01dd\u01de\7t\2\2\u01de\u01df\7p\2\2"+ - "\u01dfD\3\2\2\2\u01e0\u01e1\7u\2\2\u01e1\u01e2\7w\2\2\u01e2\u01e3\7e\2"+ - "\2\u01e3\u01e4\7e\2\2\u01e4\u01e5\7g\2\2\u01e5\u01e6\7u\2\2\u01e6\u01e7"+ - "\7u\2\2\u01e7F\3\2\2\2\u01e8\u01e9\7w\2\2\u01e9\u01ea\7p\2\2\u01ea\u01eb"+ - "\7v\2\2\u01eb\u01ec\7k\2\2\u01ec\u01ed\7n\2\2\u01edH\3\2\2\2\u01ee\u01ef"+ - "\7h\2\2\u01ef\u01f0\7c\2\2\u01f0\u01f1\7k\2\2\u01f1\u01f2\7n\2\2\u01f2"+ - "\u01f3\7w\2\2\u01f3\u01f4\7t\2\2\u01f4\u01f5\7g\2\2\u01f5J\3\2\2\2\u01f6"+ - "\u01f7\7e\2\2\u01f7\u01f8\7q\2\2\u01f8\u01f9\7p\2\2\u01f9\u01fa\7v\2\2"+ - "\u01fa\u01fb\7k\2\2\u01fb\u01fc\7p\2\2\u01fc\u01fd\7w\2\2\u01fd\u01fe"+ - "\7g\2\2\u01feL\3\2\2\2\u01ff\u0200\7d\2\2\u0200\u0201\7t\2\2\u0201\u0202"+ - "\7g\2\2\u0202\u0203\7c\2\2\u0203\u0204\7m\2\2\u0204N\3\2\2\2\u0205\u0206"+ - "\7g\2\2\u0206\u0207\7o\2\2\u0207\u0208\7r\2\2\u0208\u0209\7v\2\2\u0209"+ - "\u020a\7{\2\2\u020a\u020b\7U\2\2\u020b\u020c\7g\2\2\u020c\u020d\7v\2\2"+ - "\u020dP\3\2\2\2\u020e\u020f\7g\2\2\u020f\u0210\7o\2\2\u0210\u0211\7r\2"+ - "\2\u0211\u0212\7v\2\2\u0212\u0213\7{\2\2\u0213\u0214\7N\2\2\u0214\u0215"+ - "\7k\2\2\u0215\u0216\7u\2\2\u0216\u0217\7v\2\2\u0217R\3\2\2\2\u0218\u0219"+ - "\7g\2\2\u0219\u021a\7o\2\2\u021a\u021b\7r\2\2\u021b\u021c\7v\2\2\u021c"+ - "\u021d\7{\2\2\u021d\u021e\7U\2\2\u021e\u021f\7v\2\2\u021f\u0220\7t\2\2"+ - "\u0220\u0221\7w\2\2\u0221\u0222\7e\2\2\u0222\u0223\7v\2\2\u0223\u0224"+ - "\7w\2\2\u0224\u0225\7t\2\2\u0225\u0226\7g\2\2\u0226T\3\2\2\2\u0227\u0228"+ - "\7o\2\2\u0228\u0229\7q\2\2\u0229\u022a\7f\2\2\u022a\u022b\7k\2\2\u022b"+ - "\u022c\7h\2\2\u022c\u022d\7k\2\2\u022d\u022e\7g\2\2\u022e\u022f\7u\2\2"+ - "\u022fV\3\2\2\2\u0230\u0231\7w\2\2\u0231\u0232\7u\2\2\u0232\u0233\7g\2"+ - "\2\u0233\u0234\7u\2\2\u0234X\3\2\2\2\u0235\u0236\7k\2\2\u0236\u0237\7"+ - "p\2\2\u0237\u0238\7e\2\2\u0238\u0239\7n\2\2\u0239\u023a\7w\2\2\u023a\u023b"+ - "\7f\2\2\u023b\u023c\7g\2\2\u023cZ\3\2\2\2\u023d\u023e\7z\2\2\u023e\u023f"+ - "\7q\2\2\u023f\u0240\7t\2\2\u0240\\\3\2\2\2\u0241\u0242\7c\2\2\u0242\u0243"+ - "\7d\2\2\u0243\u0244\7u\2\2\u0244^\3\2\2\2\u0245\u0246\7c\2\2\u0246\u0247"+ - "\7e\2\2\u0247\u0248\7q\2\2\u0248\u0249\7u\2\2\u0249`\3\2\2\2\u024a\u024b"+ - "\7c\2\2\u024b\u024c\7u\2\2\u024c\u024d\7k\2\2\u024d\u024e\7p\2\2\u024e"+ - "b\3\2\2\2\u024f\u0250\7c\2\2\u0250\u0251\7v\2\2\u0251\u0252\7c\2\2\u0252"+ - "\u0253\7p\2\2\u0253d\3\2\2\2\u0254\u0255\7e\2\2\u0255\u0256\7q\2\2\u0256"+ - "\u0257\7u\2\2\u0257f\3\2\2\2\u0258\u0259\7n\2\2\u0259\u025a\7q\2\2\u025a"+ - "\u025b\7i\2\2\u025bh\3\2\2\2\u025c\u025d\7r\2\2\u025d\u025e\7k\2\2\u025e"+ - "j\3\2\2\2\u025f\u0260\7r\2\2\u0260\u0261\7q\2\2\u0261\u0262\7y\2\2\u0262"+ - "l\3\2\2\2\u0263\u0264\7u\2\2\u0264\u0265\7k\2\2\u0265\u0266\7p\2\2\u0266"+ - "n\3\2\2\2\u0267\u0268\7u\2\2\u0268\u0269\7s\2\2\u0269\u026a\7t\2\2\u026a"+ - "\u026b\7v\2\2\u026bp\3\2\2\2\u026c\u026d\7v\2\2\u026d\u026e\7c\2\2\u026e"+ - "\u026f\7p\2\2\u026fr\3\2\2\2\u0270\u0271\7n\2\2\u0271\u0272\7g\2\2\u0272"+ - "\u0273\7p\2\2\u0273t\3\2\2\2\u0274\u0275\7c\2\2\u0275\u0276\7t\2\2\u0276"+ - "\u0277\7t\2\2\u0277\u0278\7c\2\2\u0278\u0279\7{\2\2\u0279v\3\2\2\2\u027a"+ - "\u027b\7u\2\2\u027b\u027c\7g\2\2\u027c\u027d\7v\2\2\u027dx\3\2\2\2\u027e"+ - "\u027f\7c\2\2\u027f\u0280\7v\2\2\u0280z\3\2\2\2\u0281\u0282\7d\2\2\u0282"+ - "\u0283\7g\2\2\u0283\u0284\7n\2\2\u0284\u0285\7q\2\2\u0285\u0286\7p\2\2"+ - "\u0286\u0287\7i\2\2\u0287\u0288\7u\2\2\u0288\u0289\7V\2\2\u0289\u028a"+ - "\7q\2\2\u028a|\3\2\2\2\u028b\u028c\7f\2\2\u028c\u028d\7g\2\2\u028d\u028e"+ - "\7n\2\2\u028e\u028f\7g\2\2\u028f\u0290\7v\2\2\u0290\u0291\7g\2\2\u0291"+ - "~\3\2\2\2\u0292\u0293\7g\2\2\u0293\u0294\7o\2\2\u0294\u0295\7r\2\2\u0295"+ - "\u0296\7v\2\2\u0296\u0297\7{\2\2\u0297\u0080\3\2\2\2\u0298\u0299\7g\2"+ - "\2\u0299\u029a\7p\2\2\u029a\u029b\7f\2\2\u029b\u0082\3\2\2\2\u029c\u029d"+ - "\7h\2\2\u029d\u029e\7k\2\2\u029e\u029f\7t\2\2\u029f\u02a0\7u\2\2\u02a0"+ - "\u02a1\7v\2\2\u02a1\u0084\3\2\2\2\u02a2\u02a3\7h\2\2\u02a3\u02a4\7n\2"+ - "\2\u02a4\u02a5\7q\2\2\u02a5\u02a6\7c\2\2\u02a6\u02a7\7v\2\2\u02a7\u0086"+ - "\3\2\2\2\u02a8\u02a9\7k\2\2\u02a9\u02aa\7p\2\2\u02aa\u02ab\7u\2\2\u02ab"+ - "\u02ac\7g\2\2\u02ac\u02ad\7t\2\2\u02ad\u02ae\7v\2\2\u02ae\u0088\3\2\2"+ - "\2\u02af\u02b0\7k\2\2\u02b0\u02b1\7p\2\2\u02b1\u02b2\7v\2\2\u02b2\u008a"+ - "\3\2\2\2\u02b3\u02b4\7d\2\2\u02b4\u02b5\7q\2\2\u02b5\u02b6\7q\2\2\u02b6"+ - "\u02b7\7n\2\2\u02b7\u02b8\7g\2\2\u02b8\u02b9\7c\2\2\u02b9\u02ba\7p\2\2"+ - "\u02ba\u008c\3\2\2\2\u02bb\u02bc\7r\2\2\u02bc\u02bd\7t\2\2\u02bd\u02be"+ - "\7k\2\2\u02be\u02bf\7p\2\2\u02bf\u02c0\7v\2\2\u02c0\u008e\3\2\2\2\u02c1"+ - "\u02c2\7r\2\2\u02c2\u02c3\7q\2\2\u02c3\u02c4\7r\2\2\u02c4\u02c5\7D\2\2"+ - "\u02c5\u02c6\7c\2\2\u02c6\u02c7\7e\2\2\u02c7\u02c8\7m\2\2\u02c8\u0090"+ - "\3\2\2\2\u02c9\u02ca\7r\2\2\u02ca\u02cb\7q\2\2\u02cb\u02cc\7r\2\2\u02cc"+ - "\u02cd\7H\2\2\u02cd\u02ce\7t\2\2\u02ce\u02cf\7q\2\2\u02cf\u02d0\7p\2\2"+ - "\u02d0\u02d1\7v\2\2\u02d1\u0092\3\2\2\2\u02d2\u02d3\7r\2\2\u02d3\u02d4"+ - "\7w\2\2\u02d4\u02d5\7u\2\2\u02d5\u02d6\7j\2\2\u02d6\u02d7\7D\2\2\u02d7"+ - "\u02d8\7c\2\2\u02d8\u02d9\7e\2\2\u02d9\u02da\7m\2\2\u02da\u0094\3\2\2"+ - "\2\u02db\u02dc\7r\2\2\u02dc\u02dd\7w\2\2\u02dd\u02de\7u\2\2\u02de\u02df"+ - "\7j\2\2\u02df\u02e0\7H\2\2\u02e0\u02e1\7t\2\2\u02e1\u02e2\7q\2\2\u02e2"+ - "\u02e3\7p\2\2\u02e3\u02e4\7v\2\2\u02e4\u0096\3\2\2\2\u02e5\u02e6\7t\2"+ - "\2\u02e6\u02e7\7g\2\2\u02e7\u02e8\7o\2\2\u02e8\u02e9\7q\2\2\u02e9\u02ea"+ - "\7x\2\2\u02ea\u02eb\7g\2\2\u02eb\u0098\3\2\2\2\u02ec\u02ed\7t\2\2\u02ed"+ - "\u02ee\7g\2\2\u02ee\u02ef\7o\2\2\u02ef\u02f0\7q\2\2\u02f0\u02f1\7x\2\2"+ - "\u02f1\u02f2\7g\2\2\u02f2\u02f3\7C\2\2\u02f3\u02f4\7n\2\2\u02f4\u02f5"+ - "\7n\2\2\u02f5\u02f6\7G\2\2\u02f6\u02f7\7s\2\2\u02f7\u02f8\7V\2\2\u02f8"+ - "\u02f9\7q\2\2\u02f9\u009a\3\2\2\2\u02fa\u02fb\7t\2\2\u02fb\u02fc\7g\2"+ - "\2\u02fc\u02fd\7o\2\2\u02fd\u02fe\7q\2\2\u02fe\u02ff\7x\2\2\u02ff\u0300"+ - "\7g\2\2\u0300\u0301\7C\2\2\u0301\u0302\7v\2\2\u0302\u009c\3\2\2\2\u0303"+ - "\u0304\7u\2\2\u0304\u0305\7k\2\2\u0305\u0306\7p\2\2\u0306\u0307\7i\2\2"+ - "\u0307\u0308\7n\2\2\u0308\u0309\7g\2\2\u0309\u030a\7v\2\2\u030a\u030b"+ - "\7q\2\2\u030b\u030c\7p\2\2\u030c\u030d\7U\2\2\u030d\u030e\7g\2\2\u030e"+ - "\u030f\7v\2\2\u030f\u009e\3\2\2\2\u0310\u0311\7u\2\2\u0311\u0312\7k\2"+ - "\2\u0312\u0313\7|\2\2\u0313\u0314\7g\2\2\u0314\u00a0\3\2\2\2\u0315\u0316"+ - "\7u\2\2\u0316\u0317\7r\2\2\u0317\u0318\7n\2\2\u0318\u0319\7k\2\2\u0319"+ - "\u031a\7v\2\2\u031a\u00a2\3\2\2\2\u031b\u031c\7v\2\2\u031c\u031d\7q\2"+ - "\2\u031d\u031e\7r\2\2\u031e\u031f\7D\2\2\u031f\u0320\7c\2\2\u0320\u0321"+ - "\7e\2\2\u0321\u0322\7m\2\2\u0322\u00a4\3\2\2\2\u0323\u0324\7v\2\2\u0324"+ - "\u0325\7q\2\2\u0325\u0326\7r\2\2\u0326\u0327\7H\2\2\u0327\u0328\7t\2\2"+ - "\u0328\u0329\7q\2\2\u0329\u032a\7p\2\2\u032a\u032b\7v\2\2\u032b\u00a6"+ - "\3\2\2\2\u032c\u032d\7w\2\2\u032d\u032e\7r\2\2\u032e\u032f\7f\2\2\u032f"+ - "\u0330\7c\2\2\u0330\u0331\7v\2\2\u0331\u0332\7g\2\2\u0332\u00a8\3\2\2"+ - "\2\u0333\u0334\7w\2\2\u0334\u0335\7p\2\2\u0335\u0336\7k\2\2\u0336\u0337"+ - "\7h\2\2\u0337\u0338\7q\2\2\u0338\u0339\7t\2\2\u0339\u033a\7o\2\2\u033a"+ - "\u033b\7P\2\2\u033b\u033c\7c\2\2\u033c\u033d\7v\2\2\u033d\u00aa\3\2\2"+ - "\2\u033e\u033f\7h\2\2\u033f\u0340\7n\2\2\u0340\u0341\7k\2\2\u0341\u0342"+ - "\7r\2\2\u0342\u00ac\3\2\2\2\u0343\u0344\7w\2\2\u0344\u0345\7p\2\2\u0345"+ - "\u0346\7k\2\2\u0346\u0347\7h\2\2\u0347\u0348\7q\2\2\u0348\u0349\7t\2\2"+ - "\u0349\u034a\7o\2\2\u034a\u034b\7H\2\2\u034b\u034c\7n\2\2\u034c\u034d"+ - "\7q\2\2\u034d\u034e\7c\2\2\u034e\u034f\7v\2\2\u034f\u00ae\3\2\2\2\u0350"+ - "\u0351\7w\2\2\u0351\u0352\7p\2\2\u0352\u0353\7k\2\2\u0353\u0354\7h\2\2"+ - "\u0354\u0355\7q\2\2\u0355\u0356\7t\2\2\u0356\u0357\7o\2\2\u0357\u0358"+ - "\7R\2\2\u0358\u0359\7g\2\2\u0359\u035a\7t\2\2\u035a\u035b\7o\2\2\u035b"+ - "\u00b0\3\2\2\2\u035c\u035d\7u\2\2\u035d\u035e\7\60\2\2\u035e\u035f\7v"+ - "\2\2\u035f\u0360\7\60\2\2\u0360\u00b2\3\2\2\2\u0361\u0362\7&\2\2\u0362"+ - "\u00b4\3\2\2\2\u0363\u0364\7/\2\2\u0364\u0365\7@\2\2\u0365\u00b6\3\2\2"+ - "\2\u0366\u0367\7%\2\2\u0367\u00b8\3\2\2\2\u0368\u0369\7B\2\2\u0369\u00ba"+ - "\3\2\2\2\u036a\u036b\7E\2\2\u036b\u036c\7q\2\2\u036c\u036d\7w\2\2\u036d"+ - "\u036e\7p\2\2\u036e\u036f\7v\2\2\u036f\u00bc\3\2\2\2\u0370\u0371\7W\2"+ - "\2\u0371\u00be\3\2\2\2\u0372\u0373\7`\2\2\u0373\u00c0\3\2\2\2\u0374\u0375"+ - "\7^\2\2\u0375\u00c2\3\2\2\2\u0376\u0378\t\5\2\2\u0377\u0376\3\2\2\2\u0378"+ - "\u0379\3\2\2\2\u0379\u0377\3\2\2\2\u0379\u037a\3\2\2\2\u037a\u00c4\3\2"+ - "\2\2\u037b\u037d\t\5\2\2\u037c\u037b\3\2\2\2\u037d\u037e\3\2\2\2\u037e"+ - "\u037c\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u0380\3\2\2\2\u0380\u0382\5\u010b"+ - "\u0086\2\u0381\u0383\t\5\2\2\u0382\u0381\3\2\2\2\u0383\u0384\3\2\2\2\u0384"+ - "\u0382\3\2\2\2\u0384\u0385\3\2\2\2\u0385\u00c6\3\2\2\2\u0386\u0387\7v"+ - "\2\2\u0387\u0388\7t\2\2\u0388\u0389\7w\2\2\u0389\u0390\7g\2\2\u038a\u038b"+ - "\7h\2\2\u038b\u038c\7c\2\2\u038c\u038d\7n\2\2\u038d\u038e\7u\2\2\u038e"+ - "\u0390\7g\2\2\u038f\u0386\3\2\2\2\u038f\u038a\3\2\2\2\u0390\u00c8\3\2"+ - "\2\2\u0391\u0396\5\t\5\2\u0392\u0395\5\13\6\2\u0393\u0395\5\t\5\2\u0394"+ - "\u0392\3\2\2\2\u0394\u0393\3\2\2\2\u0395\u0398\3\2\2\2\u0396\u0394\3\2"+ - "\2\2\u0396\u0397\3\2\2\2\u0397\u00ca\3\2\2\2\u0398\u0396\3\2\2\2\u0399"+ - "\u039a\7-\2\2\u039a\u039b\7-\2\2\u039b\u00cc\3\2\2\2\u039c\u039d\7/\2"+ - "\2\u039d\u039e\7/\2\2\u039e\u00ce\3\2\2\2\u039f\u03a0\7(\2\2\u03a0\u00d0"+ - "\3\2\2\2\u03a1\u03a2\7-\2\2\u03a2\u03a3\7\'\2\2\u03a3\u00d2\3\2\2\2\u03a4"+ - "\u03a5\7/\2\2\u03a5\u03a6\7\'\2\2\u03a6\u00d4\3\2\2\2\u03a7\u03a8\7-\2"+ - "\2\u03a8\u03a9\7-\2\2\u03a9\u03aa\7\'\2\2\u03aa\u00d6\3\2\2\2\u03ab\u03ac"+ - "\7/\2\2\u03ac\u03ad\7/\2\2\u03ad\u03ae\7\'\2\2\u03ae\u00d8\3\2\2\2\u03af"+ - "\u03b0\7>\2\2\u03b0\u00da\3\2\2\2\u03b1\u03b2\7@\2\2\u03b2\u00dc\3\2\2"+ - "\2\u03b3\u03b4\7>\2\2\u03b4\u03b5\7?\2\2\u03b5\u00de\3\2\2\2\u03b6\u03b7"+ - "\7@\2\2\u03b7\u03b8\7?\2\2\u03b8\u00e0\3\2\2\2\u03b9\u03ba\7?\2\2\u03ba"+ - "\u03bb\7?\2\2\u03bb\u00e2\3\2\2\2\u03bc\u03bd\7#\2\2\u03bd\u03be\7?\2"+ - "\2\u03be\u00e4\3\2\2\2\u03bf\u03d5\7?\2\2\u03c0\u03c1\7-\2\2\u03c1\u03d5"+ - "\7?\2\2\u03c2\u03c3\7/\2\2\u03c3\u03d5\7?\2\2\u03c4\u03c5\7,\2\2\u03c5"+ - "\u03d5\7?\2\2\u03c6\u03c7\7\61\2\2\u03c7\u03d5\7?\2\2\u03c8\u03c9\7\'"+ - "\2\2\u03c9\u03d5\7?\2\2\u03ca\u03cb\7>\2\2\u03cb\u03cc\7>\2\2\u03cc\u03d5"+ - "\7?\2\2\u03cd\u03ce\7@\2\2\u03ce\u03cf\7@\2\2\u03cf\u03d5\7?\2\2\u03d0"+ - "\u03d1\7(\2\2\u03d1\u03d5\7?\2\2\u03d2\u03d3\7~\2\2\u03d3\u03d5\7?\2\2"+ - "\u03d4\u03bf\3\2\2\2\u03d4\u03c0\3\2\2\2\u03d4\u03c2\3\2\2\2\u03d4\u03c4"+ - "\3\2\2\2\u03d4\u03c6\3\2\2\2\u03d4\u03c8\3\2\2\2\u03d4\u03ca\3\2\2\2\u03d4"+ - "\u03cd\3\2\2\2\u03d4\u03d0\3\2\2\2\u03d4\u03d2\3\2\2\2\u03d5\u00e6\3\2"+ - "\2\2\u03d6\u03d7\7/\2\2\u03d7\u00e8\3\2\2\2\u03d8\u03d9\7-\2\2\u03d9\u00ea"+ - "\3\2\2\2\u03da\u03db\7,\2\2\u03db\u00ec\3\2\2\2\u03dc\u03dd\7\61\2\2\u03dd"+ - "\u00ee\3\2\2\2\u03de\u03df\7\'\2\2\u03df\u00f0\3\2\2\2\u03e0\u03e1\7*"+ - "\2\2\u03e1\u00f2\3\2\2\2\u03e2\u03e3\7+\2\2\u03e3\u00f4\3\2\2\2\u03e4"+ - "\u03e5\7>\2\2\u03e5\u03e6\7>\2\2\u03e6\u00f6\3\2\2\2\u03e7\u03e8\7@\2"+ - "\2\u03e8\u03e9\7@\2\2\u03e9\u00f8\3\2\2\2\u03ea\u03eb\7~\2\2\u03eb\u03ec"+ - "\7~\2\2\u03ec\u00fa\3\2\2\2\u03ed\u03ee\7(\2\2\u03ee\u03ef\7(\2\2\u03ef"+ - "\u00fc\3\2\2\2\u03f0\u03f1\7#\2\2\u03f1\u00fe\3\2\2\2\u03f2\u03f3\7=\2"+ - "\2\u03f3\u0100\3\2\2\2\u03f4\u03f5\7<\2\2\u03f5\u0102\3\2\2\2\u03f6\u03f7"+ - "\7~\2\2\u03f7\u0104\3\2\2\2\u03f8\u03f9\7}\2\2\u03f9\u0106\3\2\2\2\u03fa"+ - "\u03fb\7\177\2\2\u03fb\u0108\3\2\2\2\u03fc\u03fd\7.\2\2\u03fd\u010a\3"+ - "\2\2\2\u03fe\u03ff\7\60\2\2\u03ff\u010c\3\2\2\2\u0400\u0401\7]\2\2\u0401"+ - "\u010e\3\2\2\2\u0402\u0403\7_\2\2\u0403\u0110\3\2\2\2\u0404\u0405\7$\2"+ - "\2\u0405\u0112\3\2\2\2\u0406\u0407\7A\2\2\u0407\u0114\3\2\2\2\u0408\u040c"+ - "\7$\2\2\u0409\u040b\n\7\2\2\u040a\u0409\3\2\2\2\u040b\u040e\3\2\2\2\u040c"+ - "\u040a\3\2\2\2\u040c\u040d\3\2\2\2\u040d\u040f\3\2\2\2\u040e\u040c\3\2"+ - "\2\2\u040f\u0410\7$\2\2\u0410\u0116\3\2\2\2\16\2\u011a\u0124\u0132\u0379"+ - "\u037e\u0384\u038f\u0394\u0396\u03d4\u040c\3\b\2\2"; + "\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\3\u011a\3\2\2\2\5\u0120\3\2\2"+ + "\2\7\u012e\3\2\2\2\t\u0139\3\2\2\2\13\u013b\3\2\2\2\r\u013d\3\2\2\2\17"+ + "\u013f\3\2\2\2\21\u0146\3\2\2\2\23\u014d\3\2\2\2\25\u0156\3\2\2\2\27\u0160"+ + "\3\2\2\2\31\u0169\3\2\2\2\33\u0171\3\2\2\2\35\u0178\3\2\2\2\37\u017c\3"+ + "\2\2\2!\u0181\3\2\2\2#\u0188\3\2\2\2%\u018f\3\2\2\2\'\u0192\3\2\2\2)\u0196"+ + "\3\2\2\2+\u0199\3\2\2\2-\u019e\3\2\2\2/\u01a4\3\2\2\2\61\u01a7\3\2\2\2"+ + "\63\u01ab\3\2\2\2\65\u01b3\3\2\2\2\67\u01b6\3\2\2\29\u01bb\3\2\2\2;\u01bf"+ + "\3\2\2\2=\u01c5\3\2\2\2?\u01cc\3\2\2\2A\u01d4\3\2\2\2C\u01db\3\2\2\2E"+ + "\u01e2\3\2\2\2G\u01ea\3\2\2\2I\u01f0\3\2\2\2K\u01f8\3\2\2\2M\u0201\3\2"+ + "\2\2O\u0207\3\2\2\2Q\u0210\3\2\2\2S\u0219\3\2\2\2U\u0223\3\2\2\2W\u0232"+ + "\3\2\2\2Y\u023b\3\2\2\2[\u0240\3\2\2\2]\u0248\3\2\2\2_\u024c\3\2\2\2a"+ + "\u0250\3\2\2\2c\u0255\3\2\2\2e\u025a\3\2\2\2g\u025f\3\2\2\2i\u0263\3\2"+ + "\2\2k\u0267\3\2\2\2m\u026a\3\2\2\2o\u026e\3\2\2\2q\u0272\3\2\2\2s\u0277"+ + "\3\2\2\2u\u027b\3\2\2\2w\u027f\3\2\2\2y\u0285\3\2\2\2{\u0289\3\2\2\2}"+ + "\u028c\3\2\2\2\177\u0296\3\2\2\2\u0081\u029d\3\2\2\2\u0083\u02a3\3\2\2"+ + "\2\u0085\u02a7\3\2\2\2\u0087\u02ad\3\2\2\2\u0089\u02b3\3\2\2\2\u008b\u02ba"+ + "\3\2\2\2\u008d\u02be\3\2\2\2\u008f\u02c6\3\2\2\2\u0091\u02cc\3\2\2\2\u0093"+ + "\u02d4\3\2\2\2\u0095\u02dd\3\2\2\2\u0097\u02e6\3\2\2\2\u0099\u02f0\3\2"+ + "\2\2\u009b\u02f7\3\2\2\2\u009d\u0305\3\2\2\2\u009f\u030e\3\2\2\2\u00a1"+ + "\u031b\3\2\2\2\u00a3\u0320\3\2\2\2\u00a5\u0326\3\2\2\2\u00a7\u032e\3\2"+ + "\2\2\u00a9\u0337\3\2\2\2\u00ab\u033e\3\2\2\2\u00ad\u0349\3\2\2\2\u00af"+ + "\u034e\3\2\2\2\u00b1\u035b\3\2\2\2\u00b3\u0367\3\2\2\2\u00b5\u036c\3\2"+ + "\2\2\u00b7\u036e\3\2\2\2\u00b9\u0371\3\2\2\2\u00bb\u0373\3\2\2\2\u00bd"+ + "\u0375\3\2\2\2\u00bf\u037b\3\2\2\2\u00c1\u037d\3\2\2\2\u00c3\u037f\3\2"+ + "\2\2\u00c5\u0382\3\2\2\2\u00c7\u0387\3\2\2\2\u00c9\u039a\3\2\2\2\u00cb"+ + "\u039c\3\2\2\2\u00cd\u03a4\3\2\2\2\u00cf\u03a7\3\2\2\2\u00d1\u03aa\3\2"+ + "\2\2\u00d3\u03ac\3\2\2\2\u00d5\u03af\3\2\2\2\u00d7\u03b2\3\2\2\2\u00d9"+ + "\u03b6\3\2\2\2\u00db\u03ba\3\2\2\2\u00dd\u03bc\3\2\2\2\u00df\u03be\3\2"+ + "\2\2\u00e1\u03c1\3\2\2\2\u00e3\u03c4\3\2\2\2\u00e5\u03c7\3\2\2\2\u00e7"+ + "\u03df\3\2\2\2\u00e9\u03e1\3\2\2\2\u00eb\u03e3\3\2\2\2\u00ed\u03e5\3\2"+ + "\2\2\u00ef\u03e7\3\2\2\2\u00f1\u03e9\3\2\2\2\u00f3\u03eb\3\2\2\2\u00f5"+ + "\u03ed\3\2\2\2\u00f7\u03ef\3\2\2\2\u00f9\u03f2\3\2\2\2\u00fb\u03f5\3\2"+ + "\2\2\u00fd\u03f8\3\2\2\2\u00ff\u03fb\3\2\2\2\u0101\u03fd\3\2\2\2\u0103"+ + "\u03ff\3\2\2\2\u0105\u0401\3\2\2\2\u0107\u0403\3\2\2\2\u0109\u0405\3\2"+ + "\2\2\u010b\u0407\3\2\2\2\u010d\u0409\3\2\2\2\u010f\u040b\3\2\2\2\u0111"+ + "\u040d\3\2\2\2\u0113\u040f\3\2\2\2\u0115\u0411\3\2\2\2\u0117\u0413\3\2"+ + "\2\2\u0119\u011b\t\2\2\2\u011a\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011c"+ + "\u011a\3\2\2\2\u011c\u011d\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u011f\b\2"+ + "\2\2\u011f\4\3\2\2\2\u0120\u0121\7\61\2\2\u0121\u0122\7,\2\2\u0122\u0126"+ + "\3\2\2\2\u0123\u0125\13\2\2\2\u0124\u0123\3\2\2\2\u0125\u0128\3\2\2\2"+ + "\u0126\u0127\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0129\3\2\2\2\u0128\u0126"+ + "\3\2\2\2\u0129\u012a\7,\2\2\u012a\u012b\7\61\2\2\u012b\u012c\3\2\2\2\u012c"+ + "\u012d\b\3\2\2\u012d\6\3\2\2\2\u012e\u012f\7\61\2\2\u012f\u0130\7\61\2"+ + "\2\u0130\u0134\3\2\2\2\u0131\u0133\n\3\2\2\u0132\u0131\3\2\2\2\u0133\u0136"+ + "\3\2\2\2\u0134\u0132\3\2\2\2\u0134\u0135\3\2\2\2\u0135\u0137\3\2\2\2\u0136"+ + "\u0134\3\2\2\2\u0137\u0138\b\4\2\2\u0138\b\3\2\2\2\u0139\u013a\t\4\2\2"+ + "\u013a\n\3\2\2\2\u013b\u013c\t\5\2\2\u013c\f\3\2\2\2\u013d\u013e\t\6\2"+ + "\2\u013e\16\3\2\2\2\u013f\u0140\7c\2\2\u0140\u0141\7u\2\2\u0141\u0142"+ + "\7u\2\2\u0142\u0143\7g\2\2\u0143\u0144\7t\2\2\u0144\u0145\7v\2\2\u0145"+ + "\20\3\2\2\2\u0146\u0147\7c\2\2\u0147\u0148\7u\2\2\u0148\u0149\7u\2\2\u0149"+ + "\u014a\7w\2\2\u014a\u014b\7o\2\2\u014b\u014c\7g\2\2\u014c\22\3\2\2\2\u014d"+ + "\u014e\7u\2\2\u014e\u014f\7{\2\2\u014f\u0150\7o\2\2\u0150\u0151\7d\2\2"+ + "\u0151\u0152\7q\2\2\u0152\u0153\7n\2\2\u0153\u0154\7k\2\2\u0154\u0155"+ + "\7e\2\2\u0155\24\3\2\2\2\u0156\u0157\7k\2\2\u0157\u0158\7p\2\2\u0158\u0159"+ + "\7x\2\2\u0159\u015a\7c\2\2\u015a\u015b\7t\2\2\u015b\u015c\7k\2\2\u015c"+ + "\u015d\7c\2\2\u015d\u015e\7p\2\2\u015e\u015f\7v\2\2\u015f\26\3\2\2\2\u0160"+ + "\u0161\7t\2\2\u0161\u0162\7g\2\2\u0162\u0163\7s\2\2\u0163\u0164\7w\2\2"+ + "\u0164\u0165\7k\2\2\u0165\u0166\7t\2\2\u0166\u0167\7g\2\2\u0167\u0168"+ + "\7u\2\2\u0168\30\3\2\2\2\u0169\u016a\7g\2\2\u016a\u016b\7p\2\2\u016b\u016c"+ + "\7u\2\2\u016c\u016d\7w\2\2\u016d\u016e\7t\2\2\u016e\u016f\7g\2\2\u016f"+ + "\u0170\7u\2\2\u0170\32\3\2\2\2\u0171\u0172\7t\2\2\u0172\u0173\7g\2\2\u0173"+ + "\u0174\7u\2\2\u0174\u0175\7w\2\2\u0175\u0176\7n\2\2\u0176\u0177\7v\2\2"+ + "\u0177\34\3\2\2\2\u0178\u0179\7?\2\2\u0179\u017a\7?\2\2\u017a\u017b\7"+ + "@\2\2\u017b\36\3\2\2\2\u017c\u017d\7>\2\2\u017d\u017e\7?\2\2\u017e\u017f"+ + "\7?\2\2\u017f\u0180\7@\2\2\u0180 \3\2\2\2\u0181\u0182\7h\2\2\u0182\u0183"+ + "\7q\2\2\u0183\u0184\7t\2\2\u0184\u0185\7c\2\2\u0185\u0186\7n\2\2\u0186"+ + "\u0187\7n\2\2\u0187\"\3\2\2\2\u0188\u0189\7g\2\2\u0189\u018a\7z\2\2\u018a"+ + "\u018b\7k\2\2\u018b\u018c\7u\2\2\u018c\u018d\7v\2\2\u018d\u018e\7u\2\2"+ + "\u018e$\3\2\2\2\u018f\u0190\7<\2\2\u0190\u0191\7<\2\2\u0191&\3\2\2\2\u0192"+ + "\u0193\7~\2\2\u0193\u0194\7/\2\2\u0194\u0195\7@\2\2\u0195(\3\2\2\2\u0196"+ + "\u0197\7k\2\2\u0197\u0198\7h\2\2\u0198*\3\2\2\2\u0199\u019a\7g\2\2\u019a"+ + "\u019b\7n\2\2\u019b\u019c\7u\2\2\u019c\u019d\7g\2\2\u019d,\3\2\2\2\u019e"+ + "\u019f\7y\2\2\u019f\u01a0\7j\2\2\u01a0\u01a1\7k\2\2\u01a1\u01a2\7n\2\2"+ + "\u01a2\u01a3\7g\2\2\u01a3.\3\2\2\2\u01a4\u01a5\7f\2\2\u01a5\u01a6\7q\2"+ + "\2\u01a6\60\3\2\2\2\u01a7\u01a8\7h\2\2\u01a8\u01a9\7q\2\2\u01a9\u01aa"+ + "\7t\2\2\u01aa\62\3\2\2\2\u01ab\u01ac\7h\2\2\u01ac\u01ad\7q\2\2\u01ad\u01ae"+ + "\7t\2\2\u01ae\u01af\7g\2\2\u01af\u01b0\7c\2\2\u01b0\u01b1\7e\2\2\u01b1"+ + "\u01b2\7j\2\2\u01b2\64\3\2\2\2\u01b3\u01b4\7k\2\2\u01b4\u01b5\7p\2\2\u01b5"+ + "\66\3\2\2\2\u01b6\u01b7\7h\2\2\u01b7\u01b8\7t\2\2\u01b8\u01b9\7q\2\2\u01b9"+ + "\u01ba\7o\2\2\u01ba8\3\2\2\2\u01bb\u01bc\7q\2\2\u01bc\u01bd\7w\2\2\u01bd"+ + "\u01be\7v\2\2\u01be:\3\2\2\2\u01bf\u01c0\7j\2\2\u01c0\u01c1\7c\2\2\u01c1"+ + "\u01c2\7x\2\2\u01c2\u01c3\7q\2\2\u01c3\u01c4\7e\2\2\u01c4<\3\2\2\2\u01c5"+ + "\u01c6\7e\2\2\u01c6\u01c7\7j\2\2\u01c7\u01c8\7q\2\2\u01c8\u01c9\7q\2\2"+ + "\u01c9\u01ca\7u\2\2\u01ca\u01cb\7g\2\2\u01cb>\3\2\2\2\u01cc\u01cd\7w\2"+ + "\2\u01cd\u01ce\7p\2\2\u01ce\u01cf\7k\2\2\u01cf\u01d0\7h\2\2\u01d0\u01d1"+ + "\7q\2\2\u01d1\u01d2\7t\2\2\u01d2\u01d3\7o\2\2\u01d3@\3\2\2\2\u01d4\u01d5"+ + "\7t\2\2\u01d5\u01d6\7g\2\2\u01d6\u01d7\7r\2\2\u01d7\u01d8\7g\2\2\u01d8"+ + "\u01d9\7c\2\2\u01d9\u01da\7v\2\2\u01daB\3\2\2\2\u01db\u01dc\7t\2\2\u01dc"+ + "\u01dd\7g\2\2\u01dd\u01de\7v\2\2\u01de\u01df\7w\2\2\u01df\u01e0\7t\2\2"+ + "\u01e0\u01e1\7p\2\2\u01e1D\3\2\2\2\u01e2\u01e3\7u\2\2\u01e3\u01e4\7w\2"+ + "\2\u01e4\u01e5\7e\2\2\u01e5\u01e6\7e\2\2\u01e6\u01e7\7g\2\2\u01e7\u01e8"+ + "\7u\2\2\u01e8\u01e9\7u\2\2\u01e9F\3\2\2\2\u01ea\u01eb\7w\2\2\u01eb\u01ec"+ + "\7p\2\2\u01ec\u01ed\7v\2\2\u01ed\u01ee\7k\2\2\u01ee\u01ef\7n\2\2\u01ef"+ + "H\3\2\2\2\u01f0\u01f1\7h\2\2\u01f1\u01f2\7c\2\2\u01f2\u01f3\7k\2\2\u01f3"+ + "\u01f4\7n\2\2\u01f4\u01f5\7w\2\2\u01f5\u01f6\7t\2\2\u01f6\u01f7\7g\2\2"+ + "\u01f7J\3\2\2\2\u01f8\u01f9\7e\2\2\u01f9\u01fa\7q\2\2\u01fa\u01fb\7p\2"+ + "\2\u01fb\u01fc\7v\2\2\u01fc\u01fd\7k\2\2\u01fd\u01fe\7p\2\2\u01fe\u01ff"+ + "\7w\2\2\u01ff\u0200\7g\2\2\u0200L\3\2\2\2\u0201\u0202\7d\2\2\u0202\u0203"+ + "\7t\2\2\u0203\u0204\7g\2\2\u0204\u0205\7c\2\2\u0205\u0206\7m\2\2\u0206"+ + "N\3\2\2\2\u0207\u0208\7g\2\2\u0208\u0209\7o\2\2\u0209\u020a\7r\2\2\u020a"+ + "\u020b\7v\2\2\u020b\u020c\7{\2\2\u020c\u020d\7O\2\2\u020d\u020e\7c\2\2"+ + "\u020e\u020f\7r\2\2\u020fP\3\2\2\2\u0210\u0211\7g\2\2\u0211\u0212\7o\2"+ + "\2\u0212\u0213\7r\2\2\u0213\u0214\7v\2\2\u0214\u0215\7{\2\2\u0215\u0216"+ + "\7U\2\2\u0216\u0217\7g\2\2\u0217\u0218\7v\2\2\u0218R\3\2\2\2\u0219\u021a"+ + "\7g\2\2\u021a\u021b\7o\2\2\u021b\u021c\7r\2\2\u021c\u021d\7v\2\2\u021d"+ + "\u021e\7{\2\2\u021e\u021f\7N\2\2\u021f\u0220\7k\2\2\u0220\u0221\7u\2\2"+ + "\u0221\u0222\7v\2\2\u0222T\3\2\2\2\u0223\u0224\7g\2\2\u0224\u0225\7o\2"+ + "\2\u0225\u0226\7r\2\2\u0226\u0227\7v\2\2\u0227\u0228\7{\2\2\u0228\u0229"+ + "\7U\2\2\u0229\u022a\7v\2\2\u022a\u022b\7t\2\2\u022b\u022c\7w\2\2\u022c"+ + "\u022d\7e\2\2\u022d\u022e\7v\2\2\u022e\u022f\7w\2\2\u022f\u0230\7t\2\2"+ + "\u0230\u0231\7g\2\2\u0231V\3\2\2\2\u0232\u0233\7o\2\2\u0233\u0234\7q\2"+ + "\2\u0234\u0235\7f\2\2\u0235\u0236\7k\2\2\u0236\u0237\7h\2\2\u0237\u0238"+ + "\7k\2\2\u0238\u0239\7g\2\2\u0239\u023a\7u\2\2\u023aX\3\2\2\2\u023b\u023c"+ + "\7w\2\2\u023c\u023d\7u\2\2\u023d\u023e\7g\2\2\u023e\u023f\7u\2\2\u023f"+ + "Z\3\2\2\2\u0240\u0241\7k\2\2\u0241\u0242\7p\2\2\u0242\u0243\7e\2\2\u0243"+ + "\u0244\7n\2\2\u0244\u0245\7w\2\2\u0245\u0246\7f\2\2\u0246\u0247\7g\2\2"+ + "\u0247\\\3\2\2\2\u0248\u0249\7z\2\2\u0249\u024a\7q\2\2\u024a\u024b\7t"+ + "\2\2\u024b^\3\2\2\2\u024c\u024d\7c\2\2\u024d\u024e\7d\2\2\u024e\u024f"+ + "\7u\2\2\u024f`\3\2\2\2\u0250\u0251\7c\2\2\u0251\u0252\7e\2\2\u0252\u0253"+ + "\7q\2\2\u0253\u0254\7u\2\2\u0254b\3\2\2\2\u0255\u0256\7c\2\2\u0256\u0257"+ + "\7u\2\2\u0257\u0258\7k\2\2\u0258\u0259\7p\2\2\u0259d\3\2\2\2\u025a\u025b"+ + "\7c\2\2\u025b\u025c\7v\2\2\u025c\u025d\7c\2\2\u025d\u025e\7p\2\2\u025e"+ + "f\3\2\2\2\u025f\u0260\7e\2\2\u0260\u0261\7q\2\2\u0261\u0262\7u\2\2\u0262"+ + "h\3\2\2\2\u0263\u0264\7n\2\2\u0264\u0265\7q\2\2\u0265\u0266\7i\2\2\u0266"+ + "j\3\2\2\2\u0267\u0268\7r\2\2\u0268\u0269\7k\2\2\u0269l\3\2\2\2\u026a\u026b"+ + "\7r\2\2\u026b\u026c\7q\2\2\u026c\u026d\7y\2\2\u026dn\3\2\2\2\u026e\u026f"+ + "\7u\2\2\u026f\u0270\7k\2\2\u0270\u0271\7p\2\2\u0271p\3\2\2\2\u0272\u0273"+ + "\7u\2\2\u0273\u0274\7s\2\2\u0274\u0275\7t\2\2\u0275\u0276\7v\2\2\u0276"+ + "r\3\2\2\2\u0277\u0278\7v\2\2\u0278\u0279\7c\2\2\u0279\u027a\7p\2\2\u027a"+ + "t\3\2\2\2\u027b\u027c\7n\2\2\u027c\u027d\7g\2\2\u027d\u027e\7p\2\2\u027e"+ + "v\3\2\2\2\u027f\u0280\7c\2\2\u0280\u0281\7t\2\2\u0281\u0282\7t\2\2\u0282"+ + "\u0283\7c\2\2\u0283\u0284\7{\2\2\u0284x\3\2\2\2\u0285\u0286\7u\2\2\u0286"+ + "\u0287\7g\2\2\u0287\u0288\7v\2\2\u0288z\3\2\2\2\u0289\u028a\7c\2\2\u028a"+ + "\u028b\7v\2\2\u028b|\3\2\2\2\u028c\u028d\7d\2\2\u028d\u028e\7g\2\2\u028e"+ + "\u028f\7n\2\2\u028f\u0290\7q\2\2\u0290\u0291\7p\2\2\u0291\u0292\7i\2\2"+ + "\u0292\u0293\7u\2\2\u0293\u0294\7V\2\2\u0294\u0295\7q\2\2\u0295~\3\2\2"+ + "\2\u0296\u0297\7f\2\2\u0297\u0298\7g\2\2\u0298\u0299\7n\2\2\u0299\u029a"+ + "\7g\2\2\u029a\u029b\7v\2\2\u029b\u029c\7g\2\2\u029c\u0080\3\2\2\2\u029d"+ + "\u029e\7g\2\2\u029e\u029f\7o\2\2\u029f\u02a0\7r\2\2\u02a0\u02a1\7v\2\2"+ + "\u02a1\u02a2\7{\2\2\u02a2\u0082\3\2\2\2\u02a3\u02a4\7g\2\2\u02a4\u02a5"+ + "\7p\2\2\u02a5\u02a6\7f\2\2\u02a6\u0084\3\2\2\2\u02a7\u02a8\7h\2\2\u02a8"+ + "\u02a9\7k\2\2\u02a9\u02aa\7t\2\2\u02aa\u02ab\7u\2\2\u02ab\u02ac\7v\2\2"+ + "\u02ac\u0086\3\2\2\2\u02ad\u02ae\7h\2\2\u02ae\u02af\7n\2\2\u02af\u02b0"+ + "\7q\2\2\u02b0\u02b1\7c\2\2\u02b1\u02b2\7v\2\2\u02b2\u0088\3\2\2\2\u02b3"+ + "\u02b4\7k\2\2\u02b4\u02b5\7p\2\2\u02b5\u02b6\7u\2\2\u02b6\u02b7\7g\2\2"+ + "\u02b7\u02b8\7t\2\2\u02b8\u02b9\7v\2\2\u02b9\u008a\3\2\2\2\u02ba\u02bb"+ + "\7k\2\2\u02bb\u02bc\7p\2\2\u02bc\u02bd\7v\2\2\u02bd\u008c\3\2\2\2\u02be"+ + "\u02bf\7d\2\2\u02bf\u02c0\7q\2\2\u02c0\u02c1\7q\2\2\u02c1\u02c2\7n\2\2"+ + "\u02c2\u02c3\7g\2\2\u02c3\u02c4\7c\2\2\u02c4\u02c5\7p\2\2\u02c5\u008e"+ + "\3\2\2\2\u02c6\u02c7\7r\2\2\u02c7\u02c8\7t\2\2\u02c8\u02c9\7k\2\2\u02c9"+ + "\u02ca\7p\2\2\u02ca\u02cb\7v\2\2\u02cb\u0090\3\2\2\2\u02cc\u02cd\7r\2"+ + "\2\u02cd\u02ce\7q\2\2\u02ce\u02cf\7r\2\2\u02cf\u02d0\7D\2\2\u02d0\u02d1"+ + "\7c\2\2\u02d1\u02d2\7e\2\2\u02d2\u02d3\7m\2\2\u02d3\u0092\3\2\2\2\u02d4"+ + "\u02d5\7r\2\2\u02d5\u02d6\7q\2\2\u02d6\u02d7\7r\2\2\u02d7\u02d8\7H\2\2"+ + "\u02d8\u02d9\7t\2\2\u02d9\u02da\7q\2\2\u02da\u02db\7p\2\2\u02db\u02dc"+ + "\7v\2\2\u02dc\u0094\3\2\2\2\u02dd\u02de\7r\2\2\u02de\u02df\7w\2\2\u02df"+ + "\u02e0\7u\2\2\u02e0\u02e1\7j\2\2\u02e1\u02e2\7D\2\2\u02e2\u02e3\7c\2\2"+ + "\u02e3\u02e4\7e\2\2\u02e4\u02e5\7m\2\2\u02e5\u0096\3\2\2\2\u02e6\u02e7"+ + "\7r\2\2\u02e7\u02e8\7w\2\2\u02e8\u02e9\7u\2\2\u02e9\u02ea\7j\2\2\u02ea"+ + "\u02eb\7H\2\2\u02eb\u02ec\7t\2\2\u02ec\u02ed\7q\2\2\u02ed\u02ee\7p\2\2"+ + "\u02ee\u02ef\7v\2\2\u02ef\u0098\3\2\2\2\u02f0\u02f1\7t\2\2\u02f1\u02f2"+ + "\7g\2\2\u02f2\u02f3\7o\2\2\u02f3\u02f4\7q\2\2\u02f4\u02f5\7x\2\2\u02f5"+ + "\u02f6\7g\2\2\u02f6\u009a\3\2\2\2\u02f7\u02f8\7t\2\2\u02f8\u02f9\7g\2"+ + "\2\u02f9\u02fa\7o\2\2\u02fa\u02fb\7q\2\2\u02fb\u02fc\7x\2\2\u02fc\u02fd"+ + "\7g\2\2\u02fd\u02fe\7C\2\2\u02fe\u02ff\7n\2\2\u02ff\u0300\7n\2\2\u0300"+ + "\u0301\7G\2\2\u0301\u0302\7s\2\2\u0302\u0303\7V\2\2\u0303\u0304\7q\2\2"+ + "\u0304\u009c\3\2\2\2\u0305\u0306\7t\2\2\u0306\u0307\7g\2\2\u0307\u0308"+ + "\7o\2\2\u0308\u0309\7q\2\2\u0309\u030a\7x\2\2\u030a\u030b\7g\2\2\u030b"+ + "\u030c\7C\2\2\u030c\u030d\7v\2\2\u030d\u009e\3\2\2\2\u030e\u030f\7u\2"+ + "\2\u030f\u0310\7k\2\2\u0310\u0311\7p\2\2\u0311\u0312\7i\2\2\u0312\u0313"+ + "\7n\2\2\u0313\u0314\7g\2\2\u0314\u0315\7v\2\2\u0315\u0316\7q\2\2\u0316"+ + "\u0317\7p\2\2\u0317\u0318\7U\2\2\u0318\u0319\7g\2\2\u0319\u031a\7v\2\2"+ + "\u031a\u00a0\3\2\2\2\u031b\u031c\7u\2\2\u031c\u031d\7k\2\2\u031d\u031e"+ + "\7|\2\2\u031e\u031f\7g\2\2\u031f\u00a2\3\2\2\2\u0320\u0321\7u\2\2\u0321"+ + "\u0322\7r\2\2\u0322\u0323\7n\2\2\u0323\u0324\7k\2\2\u0324\u0325\7v\2\2"+ + "\u0325\u00a4\3\2\2\2\u0326\u0327\7v\2\2\u0327\u0328\7q\2\2\u0328\u0329"+ + "\7r\2\2\u0329\u032a\7D\2\2\u032a\u032b\7c\2\2\u032b\u032c\7e\2\2\u032c"+ + "\u032d\7m\2\2\u032d\u00a6\3\2\2\2\u032e\u032f\7v\2\2\u032f\u0330\7q\2"+ + "\2\u0330\u0331\7r\2\2\u0331\u0332\7H\2\2\u0332\u0333\7t\2\2\u0333\u0334"+ + "\7q\2\2\u0334\u0335\7p\2\2\u0335\u0336\7v\2\2\u0336\u00a8\3\2\2\2\u0337"+ + "\u0338\7w\2\2\u0338\u0339\7r\2\2\u0339\u033a\7f\2\2\u033a\u033b\7c\2\2"+ + "\u033b\u033c\7v\2\2\u033c\u033d\7g\2\2\u033d\u00aa\3\2\2\2\u033e\u033f"+ + "\7w\2\2\u033f\u0340\7p\2\2\u0340\u0341\7k\2\2\u0341\u0342\7h\2\2\u0342"+ + "\u0343\7q\2\2\u0343\u0344\7t\2\2\u0344\u0345\7o\2\2\u0345\u0346\7P\2\2"+ + "\u0346\u0347\7c\2\2\u0347\u0348\7v\2\2\u0348\u00ac\3\2\2\2\u0349\u034a"+ + "\7h\2\2\u034a\u034b\7n\2\2\u034b\u034c\7k\2\2\u034c\u034d\7r\2\2\u034d"+ + "\u00ae\3\2\2\2\u034e\u034f\7w\2\2\u034f\u0350\7p\2\2\u0350\u0351\7k\2"+ + "\2\u0351\u0352\7h\2\2\u0352\u0353\7q\2\2\u0353\u0354\7t\2\2\u0354\u0355"+ + "\7o\2\2\u0355\u0356\7H\2\2\u0356\u0357\7n\2\2\u0357\u0358\7q\2\2\u0358"+ + "\u0359\7c\2\2\u0359\u035a\7v\2\2\u035a\u00b0\3\2\2\2\u035b\u035c\7w\2"+ + "\2\u035c\u035d\7p\2\2\u035d\u035e\7k\2\2\u035e\u035f\7h\2\2\u035f\u0360"+ + "\7q\2\2\u0360\u0361\7t\2\2\u0361\u0362\7o\2\2\u0362\u0363\7R\2\2\u0363"+ + "\u0364\7g\2\2\u0364\u0365\7t\2\2\u0365\u0366\7o\2\2\u0366\u00b2\3\2\2"+ + "\2\u0367\u0368\7u\2\2\u0368\u0369\7\60\2\2\u0369\u036a\7v\2\2\u036a\u036b"+ + "\7\60\2\2\u036b\u00b4\3\2\2\2\u036c\u036d\7&\2\2\u036d\u00b6\3\2\2\2\u036e"+ + "\u036f\7/\2\2\u036f\u0370\7@\2\2\u0370\u00b8\3\2\2\2\u0371\u0372\7%\2"+ + "\2\u0372\u00ba\3\2\2\2\u0373\u0374\7B\2\2\u0374\u00bc\3\2\2\2\u0375\u0376"+ + "\7E\2\2\u0376\u0377\7q\2\2\u0377\u0378\7w\2\2\u0378\u0379\7p\2\2\u0379"+ + "\u037a\7v\2\2\u037a\u00be\3\2\2\2\u037b\u037c\7W\2\2\u037c\u00c0\3\2\2"+ + "\2\u037d\u037e\7`\2\2\u037e\u00c2\3\2\2\2\u037f\u0380\7^\2\2\u0380\u00c4"+ + "\3\2\2\2\u0381\u0383\t\5\2\2\u0382\u0381\3\2\2\2\u0383\u0384\3\2\2\2\u0384"+ + "\u0382\3\2\2\2\u0384\u0385\3\2\2\2\u0385\u00c6\3\2\2\2\u0386\u0388\t\5"+ + "\2\2\u0387\u0386\3\2\2\2\u0388\u0389\3\2\2\2\u0389\u0387\3\2\2\2\u0389"+ + "\u038a\3\2\2\2\u038a\u038b\3\2\2\2\u038b\u038d\5\u010d\u0087\2\u038c\u038e"+ + "\t\5\2\2\u038d\u038c\3\2\2\2\u038e\u038f\3\2\2\2\u038f\u038d\3\2\2\2\u038f"+ + "\u0390\3\2\2\2\u0390\u00c8\3\2\2\2\u0391\u0392\7v\2\2\u0392\u0393\7t\2"+ + "\2\u0393\u0394\7w\2\2\u0394\u039b\7g\2\2\u0395\u0396\7h\2\2\u0396\u0397"+ + "\7c\2\2\u0397\u0398\7n\2\2\u0398\u0399\7u\2\2\u0399\u039b\7g\2\2\u039a"+ + "\u0391\3\2\2\2\u039a\u0395\3\2\2\2\u039b\u00ca\3\2\2\2\u039c\u03a1\5\t"+ + "\5\2\u039d\u03a0\5\13\6\2\u039e\u03a0\5\t\5\2\u039f\u039d\3\2\2\2\u039f"+ + "\u039e\3\2\2\2\u03a0\u03a3\3\2\2\2\u03a1\u039f\3\2\2\2\u03a1\u03a2\3\2"+ + "\2\2\u03a2\u00cc\3\2\2\2\u03a3\u03a1\3\2\2\2\u03a4\u03a5\7-\2\2\u03a5"+ + "\u03a6\7-\2\2\u03a6\u00ce\3\2\2\2\u03a7\u03a8\7/\2\2\u03a8\u03a9\7/\2"+ + "\2\u03a9\u00d0\3\2\2\2\u03aa\u03ab\7(\2\2\u03ab\u00d2\3\2\2\2\u03ac\u03ad"+ + "\7-\2\2\u03ad\u03ae\7\'\2\2\u03ae\u00d4\3\2\2\2\u03af\u03b0\7/\2\2\u03b0"+ + "\u03b1\7\'\2\2\u03b1\u00d6\3\2\2\2\u03b2\u03b3\7-\2\2\u03b3\u03b4\7-\2"+ + "\2\u03b4\u03b5\7\'\2\2\u03b5\u00d8\3\2\2\2\u03b6\u03b7\7/\2\2\u03b7\u03b8"+ + "\7/\2\2\u03b8\u03b9\7\'\2\2\u03b9\u00da\3\2\2\2\u03ba\u03bb\7>\2\2\u03bb"+ + "\u00dc\3\2\2\2\u03bc\u03bd\7@\2\2\u03bd\u00de\3\2\2\2\u03be\u03bf\7>\2"+ + "\2\u03bf\u03c0\7?\2\2\u03c0\u00e0\3\2\2\2\u03c1\u03c2\7@\2\2\u03c2\u03c3"+ + "\7?\2\2\u03c3\u00e2\3\2\2\2\u03c4\u03c5\7?\2\2\u03c5\u03c6\7?\2\2\u03c6"+ + "\u00e4\3\2\2\2\u03c7\u03c8\7#\2\2\u03c8\u03c9\7?\2\2\u03c9\u00e6\3\2\2"+ + "\2\u03ca\u03e0\7?\2\2\u03cb\u03cc\7-\2\2\u03cc\u03e0\7?\2\2\u03cd\u03ce"+ + "\7/\2\2\u03ce\u03e0\7?\2\2\u03cf\u03d0\7,\2\2\u03d0\u03e0\7?\2\2\u03d1"+ + "\u03d2\7\61\2\2\u03d2\u03e0\7?\2\2\u03d3\u03d4\7\'\2\2\u03d4\u03e0\7?"+ + "\2\2\u03d5\u03d6\7>\2\2\u03d6\u03d7\7>\2\2\u03d7\u03e0\7?\2\2\u03d8\u03d9"+ + "\7@\2\2\u03d9\u03da\7@\2\2\u03da\u03e0\7?\2\2\u03db\u03dc\7(\2\2\u03dc"+ + "\u03e0\7?\2\2\u03dd\u03de\7~\2\2\u03de\u03e0\7?\2\2\u03df\u03ca\3\2\2"+ + "\2\u03df\u03cb\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03cf\3\2\2\2\u03df\u03d1"+ + "\3\2\2\2\u03df\u03d3\3\2\2\2\u03df\u03d5\3\2\2\2\u03df\u03d8\3\2\2\2\u03df"+ + "\u03db\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0\u00e8\3\2\2\2\u03e1\u03e2\7/"+ + "\2\2\u03e2\u00ea\3\2\2\2\u03e3\u03e4\7-\2\2\u03e4\u00ec\3\2\2\2\u03e5"+ + "\u03e6\7,\2\2\u03e6\u00ee\3\2\2\2\u03e7\u03e8\7\61\2\2\u03e8\u00f0\3\2"+ + "\2\2\u03e9\u03ea\7\'\2\2\u03ea\u00f2\3\2\2\2\u03eb\u03ec\7*\2\2\u03ec"+ + "\u00f4\3\2\2\2\u03ed\u03ee\7+\2\2\u03ee\u00f6\3\2\2\2\u03ef\u03f0\7>\2"+ + "\2\u03f0\u03f1\7>\2\2\u03f1\u00f8\3\2\2\2\u03f2\u03f3\7@\2\2\u03f3\u03f4"+ + "\7@\2\2\u03f4\u00fa\3\2\2\2\u03f5\u03f6\7~\2\2\u03f6\u03f7\7~\2\2\u03f7"+ + "\u00fc\3\2\2\2\u03f8\u03f9\7(\2\2\u03f9\u03fa\7(\2\2\u03fa\u00fe\3\2\2"+ + "\2\u03fb\u03fc\7#\2\2\u03fc\u0100\3\2\2\2\u03fd\u03fe\7=\2\2\u03fe\u0102"+ + "\3\2\2\2\u03ff\u0400\7<\2\2\u0400\u0104\3\2\2\2\u0401\u0402\7~\2\2\u0402"+ + "\u0106\3\2\2\2\u0403\u0404\7}\2\2\u0404\u0108\3\2\2\2\u0405\u0406\7\177"+ + "\2\2\u0406\u010a\3\2\2\2\u0407\u0408\7.\2\2\u0408\u010c\3\2\2\2\u0409"+ + "\u040a\7\60\2\2\u040a\u010e\3\2\2\2\u040b\u040c\7]\2\2\u040c\u0110\3\2"+ + "\2\2\u040d\u040e\7_\2\2\u040e\u0112\3\2\2\2\u040f\u0410\7$\2\2\u0410\u0114"+ + "\3\2\2\2\u0411\u0412\7A\2\2\u0412\u0116\3\2\2\2\u0413\u0417\7$\2\2\u0414"+ + "\u0416\n\7\2\2\u0415\u0414\3\2\2\2\u0416\u0419\3\2\2\2\u0417\u0415\3\2"+ + "\2\2\u0417\u0418\3\2\2\2\u0418\u041a\3\2\2\2\u0419\u0417\3\2\2\2\u041a"+ + "\u041b\7$\2\2\u041b\u0118\3\2\2\2\16\2\u011c\u0126\u0134\u0384\u0389\u038f"+ + "\u039a\u039f\u03a1\u03df\u0417\3\b\2\2"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static { diff --git a/src/main/java/grammar/alkLexer.tokens b/src/main/java/grammar/alkLexer.tokens index cbdc4f5a..67a292e6 100644 --- a/src/main/java/grammar/alkLexer.tokens +++ b/src/main/java/grammar/alkLexer.tokens @@ -33,106 +33,107 @@ UNTIL=32 FAILURE=33 CONTINUE=34 BREAK=35 -EMPTYSET=36 -EMPTYLIST=37 -EMPTYSTRUCTURE=38 -MODIFIES=39 -USES=40 -INCLDUE=41 -XOR=42 -ABS=43 -ACOS=44 -ASIN=45 -ATAN=46 -COS=47 -LOG=48 -PI=49 -POW=50 -SIN=51 -SQRT=52 -TAN=53 -LEN=54 -ARRAY=55 -SET=56 -AT=57 -BELONGSTO=58 -DELETE=59 -EMPTY=60 -END=61 -FIRST=62 -FLOAT=63 -INSERT=64 -INTEGER=65 -BOOLEAN=66 -PRINT=67 -POPBACK=68 -POPFRONT=69 -PUSHBACK=70 -PUSHFRONT=71 -REMOVE=72 -REMOVEALLEQTO=73 -REMOVEAT=74 -SINGLETONSET=75 -SIZE=76 -SPLIT=77 -TOPBACK=78 -TOPFRONT=79 -UPDATE=80 -UNIFORMNAT=81 -FLIP=82 -UNIFORMFLOAT=83 -UNIFORMPERM=84 -SOTHAT=85 -SYM=86 -ARROW=87 -NUMSIGN=88 -ANNO=89 -COUNT=90 -UNION=91 -INTERSECT=92 -SUBTRACT=93 -INT=94 -DOUBLE=95 -BOOL=96 -ID=97 -PLUSPLUS=98 -MINUSMINUS=99 -BITWISE_AND=100 -PLUSMOD=101 -MINUSMOD=102 -PLUSPLUSMOD=103 -MINUSMINUSMOD=104 -LOWER=105 -GREATER=106 -LOWEREQ=107 -GREATEREQ=108 -ISEQUAL=109 -NOTEQUAL=110 -ASSIGNMENT_OPERATOR=111 -MINUS=112 -PLUS=113 -MUL=114 -DIV=115 -MOD=116 -LPAR=117 -RPAR=118 -LEFTSHIFT=119 -RIGHTSHIFT=120 -OR=121 -AND=122 -NOT=123 -SEMICOLON=124 -DPOINT=125 -VBAR=126 -LCB=127 -RCB=128 -COMMA=129 -POINT=130 -LBRA=131 -RBRA=132 -QUOTE=133 -QUESTION=134 -STRING=135 +EMPTYMAP=36 +EMPTYSET=37 +EMPTYLIST=38 +EMPTYSTRUCTURE=39 +MODIFIES=40 +USES=41 +INCLDUE=42 +XOR=43 +ABS=44 +ACOS=45 +ASIN=46 +ATAN=47 +COS=48 +LOG=49 +PI=50 +POW=51 +SIN=52 +SQRT=53 +TAN=54 +LEN=55 +ARRAY=56 +SET=57 +AT=58 +BELONGSTO=59 +DELETE=60 +EMPTY=61 +END=62 +FIRST=63 +FLOAT=64 +INSERT=65 +INTEGER=66 +BOOLEAN=67 +PRINT=68 +POPBACK=69 +POPFRONT=70 +PUSHBACK=71 +PUSHFRONT=72 +REMOVE=73 +REMOVEALLEQTO=74 +REMOVEAT=75 +SINGLETONSET=76 +SIZE=77 +SPLIT=78 +TOPBACK=79 +TOPFRONT=80 +UPDATE=81 +UNIFORMNAT=82 +FLIP=83 +UNIFORMFLOAT=84 +UNIFORMPERM=85 +SOTHAT=86 +SYM=87 +ARROW=88 +NUMSIGN=89 +ANNO=90 +COUNT=91 +UNION=92 +INTERSECT=93 +SUBTRACT=94 +INT=95 +DOUBLE=96 +BOOL=97 +ID=98 +PLUSPLUS=99 +MINUSMINUS=100 +BITWISE_AND=101 +PLUSMOD=102 +MINUSMOD=103 +PLUSPLUSMOD=104 +MINUSMINUSMOD=105 +LOWER=106 +GREATER=107 +LOWEREQ=108 +GREATEREQ=109 +ISEQUAL=110 +NOTEQUAL=111 +ASSIGNMENT_OPERATOR=112 +MINUS=113 +PLUS=114 +MUL=115 +DIV=116 +MOD=117 +LPAR=118 +RPAR=119 +LEFTSHIFT=120 +RIGHTSHIFT=121 +OR=122 +AND=123 +NOT=124 +SEMICOLON=125 +DPOINT=126 +VBAR=127 +LCB=128 +RCB=129 +COMMA=130 +POINT=131 +LBRA=132 +RBRA=133 +QUOTE=134 +QUESTION=135 +STRING=136 'assert'=4 'assume'=5 'symbolic'=6 @@ -165,97 +166,98 @@ STRING=135 'failure'=33 'continue'=34 'break'=35 -'emptySet'=36 -'emptyList'=37 -'emptyStructure'=38 -'modifies'=39 -'uses'=40 -'include'=41 -'xor'=42 -'abs'=43 -'acos'=44 -'asin'=45 -'atan'=46 -'cos'=47 -'log'=48 -'pi'=49 -'pow'=50 -'sin'=51 -'sqrt'=52 -'tan'=53 -'len'=54 -'array'=55 -'set'=56 -'at'=57 -'belongsTo'=58 -'delete'=59 -'empty'=60 -'end'=61 -'first'=62 -'float'=63 -'insert'=64 -'int'=65 -'boolean'=66 -'print'=67 -'popBack'=68 -'popFront'=69 -'pushBack'=70 -'pushFront'=71 -'remove'=72 -'removeAllEqTo'=73 -'removeAt'=74 -'singletonSet'=75 -'size'=76 -'split'=77 -'topBack'=78 -'topFront'=79 -'update'=80 -'uniformNat'=81 -'flip'=82 -'uniformFloat'=83 -'uniformPerm'=84 -'s.t.'=85 -'$'=86 -'->'=87 -'#'=88 -'@'=89 -'Count'=90 -'U'=91 -'^'=92 -'\\'=93 -'++'=98 -'--'=99 -'&'=100 -'+%'=101 -'-%'=102 -'++%'=103 -'--%'=104 -'<'=105 -'>'=106 -'<='=107 -'>='=108 -'=='=109 -'!='=110 -'-'=112 -'+'=113 -'*'=114 -'/'=115 -'%'=116 -'('=117 -')'=118 -'<<'=119 -'>>'=120 -'||'=121 -'&&'=122 -'!'=123 -';'=124 -':'=125 -'|'=126 -'{'=127 -'}'=128 -','=129 -'.'=130 -'['=131 -']'=132 -'"'=133 -'?'=134 +'emptyMap'=36 +'emptySet'=37 +'emptyList'=38 +'emptyStructure'=39 +'modifies'=40 +'uses'=41 +'include'=42 +'xor'=43 +'abs'=44 +'acos'=45 +'asin'=46 +'atan'=47 +'cos'=48 +'log'=49 +'pi'=50 +'pow'=51 +'sin'=52 +'sqrt'=53 +'tan'=54 +'len'=55 +'array'=56 +'set'=57 +'at'=58 +'belongsTo'=59 +'delete'=60 +'empty'=61 +'end'=62 +'first'=63 +'float'=64 +'insert'=65 +'int'=66 +'boolean'=67 +'print'=68 +'popBack'=69 +'popFront'=70 +'pushBack'=71 +'pushFront'=72 +'remove'=73 +'removeAllEqTo'=74 +'removeAt'=75 +'singletonSet'=76 +'size'=77 +'split'=78 +'topBack'=79 +'topFront'=80 +'update'=81 +'uniformNat'=82 +'flip'=83 +'uniformFloat'=84 +'uniformPerm'=85 +'s.t.'=86 +'$'=87 +'->'=88 +'#'=89 +'@'=90 +'Count'=91 +'U'=92 +'^'=93 +'\\'=94 +'++'=99 +'--'=100 +'&'=101 +'+%'=102 +'-%'=103 +'++%'=104 +'--%'=105 +'<'=106 +'>'=107 +'<='=108 +'>='=109 +'=='=110 +'!='=111 +'-'=113 +'+'=114 +'*'=115 +'/'=116 +'%'=117 +'('=118 +')'=119 +'<<'=120 +'>>'=121 +'||'=122 +'&&'=123 +'!'=124 +';'=125 +':'=126 +'|'=127 +'{'=128 +'}'=129 +','=130 +'.'=131 +'['=132 +']'=133 +'"'=134 +'?'=135 diff --git a/src/main/java/grammar/alkParser.java b/src/main/java/grammar/alkParser.java index 8cde7a83..1366d70b 100644 --- a/src/main/java/grammar/alkParser.java +++ b/src/main/java/grammar/alkParser.java @@ -23,23 +23,23 @@ public class alkParser extends Parser { REQURIES=8, ENSURES=9, RESULT=10, IMPLIES=11, EQUIV=12, FORALL=13, EXISTS=14, QUANTIFIER_SEPARATOR=15, TO=16, IF=17, ELSE=18, WHILE=19, DO=20, FOR=21, FOREACH=22, IN=23, FROM=24, OUT=25, HAVOC=26, CHOOSE=27, UNIFORM=28, REPEAT=29, - RETURN=30, SUCCESS=31, UNTIL=32, FAILURE=33, CONTINUE=34, BREAK=35, EMPTYSET=36, - EMPTYLIST=37, EMPTYSTRUCTURE=38, MODIFIES=39, USES=40, INCLDUE=41, XOR=42, - ABS=43, ACOS=44, ASIN=45, ATAN=46, COS=47, LOG=48, PI=49, POW=50, SIN=51, - SQRT=52, TAN=53, LEN=54, ARRAY=55, SET=56, AT=57, BELONGSTO=58, DELETE=59, - EMPTY=60, END=61, FIRST=62, FLOAT=63, INSERT=64, INTEGER=65, BOOLEAN=66, - PRINT=67, POPBACK=68, POPFRONT=69, PUSHBACK=70, PUSHFRONT=71, REMOVE=72, - REMOVEALLEQTO=73, REMOVEAT=74, SINGLETONSET=75, SIZE=76, SPLIT=77, TOPBACK=78, - TOPFRONT=79, UPDATE=80, UNIFORMNAT=81, FLIP=82, UNIFORMFLOAT=83, UNIFORMPERM=84, - SOTHAT=85, SYM=86, ARROW=87, NUMSIGN=88, ANNO=89, COUNT=90, UNION=91, - INTERSECT=92, SUBTRACT=93, INT=94, DOUBLE=95, BOOL=96, ID=97, PLUSPLUS=98, - MINUSMINUS=99, BITWISE_AND=100, PLUSMOD=101, MINUSMOD=102, PLUSPLUSMOD=103, - MINUSMINUSMOD=104, LOWER=105, GREATER=106, LOWEREQ=107, GREATEREQ=108, - ISEQUAL=109, NOTEQUAL=110, ASSIGNMENT_OPERATOR=111, MINUS=112, PLUS=113, - MUL=114, DIV=115, MOD=116, LPAR=117, RPAR=118, LEFTSHIFT=119, RIGHTSHIFT=120, - OR=121, AND=122, NOT=123, SEMICOLON=124, DPOINT=125, VBAR=126, LCB=127, - RCB=128, COMMA=129, POINT=130, LBRA=131, RBRA=132, QUOTE=133, QUESTION=134, - STRING=135; + RETURN=30, SUCCESS=31, UNTIL=32, FAILURE=33, CONTINUE=34, BREAK=35, EMPTYMAP=36, + EMPTYSET=37, EMPTYLIST=38, EMPTYSTRUCTURE=39, MODIFIES=40, USES=41, INCLDUE=42, + XOR=43, ABS=44, ACOS=45, ASIN=46, ATAN=47, COS=48, LOG=49, PI=50, POW=51, + SIN=52, SQRT=53, TAN=54, LEN=55, ARRAY=56, SET=57, AT=58, BELONGSTO=59, + DELETE=60, EMPTY=61, END=62, FIRST=63, FLOAT=64, INSERT=65, INTEGER=66, + BOOLEAN=67, PRINT=68, POPBACK=69, POPFRONT=70, PUSHBACK=71, PUSHFRONT=72, + REMOVE=73, REMOVEALLEQTO=74, REMOVEAT=75, SINGLETONSET=76, SIZE=77, SPLIT=78, + TOPBACK=79, TOPFRONT=80, UPDATE=81, UNIFORMNAT=82, FLIP=83, UNIFORMFLOAT=84, + UNIFORMPERM=85, SOTHAT=86, SYM=87, ARROW=88, NUMSIGN=89, ANNO=90, COUNT=91, + UNION=92, INTERSECT=93, SUBTRACT=94, INT=95, DOUBLE=96, BOOL=97, ID=98, + PLUSPLUS=99, MINUSMINUS=100, BITWISE_AND=101, PLUSMOD=102, MINUSMOD=103, + PLUSPLUSMOD=104, MINUSMINUSMOD=105, LOWER=106, GREATER=107, LOWEREQ=108, + GREATEREQ=109, ISEQUAL=110, NOTEQUAL=111, ASSIGNMENT_OPERATOR=112, MINUS=113, + PLUS=114, MUL=115, DIV=116, MOD=117, LPAR=118, RPAR=119, LEFTSHIFT=120, + RIGHTSHIFT=121, OR=122, AND=123, NOT=124, SEMICOLON=125, DPOINT=126, VBAR=127, + LCB=128, RCB=129, COMMA=130, POINT=131, LBRA=132, RBRA=133, QUOTE=134, + QUESTION=135, STRING=136; public static final int RULE_main = 0, RULE_statement_sequence = 1, RULE_statement = 2, RULE_assumeStmt = 3, RULE_assertStmt = 4, RULE_havocStmt = 5, RULE_symbolicStmt = 6, RULE_symbolicDeclarator = 7, @@ -55,9 +55,9 @@ public class alkParser extends Parser { RULE_factor = 37, RULE_base_factor = 38, RULE_anno = 39, RULE_value = 40, RULE_scalar_value = 41, RULE_ref_name = 42, RULE_data_structure = 43, RULE_interval = 44, RULE_spec = 45, RULE_array = 46, RULE_list = 47, RULE_structure = 48, - RULE_component = 49, RULE_set = 50, RULE_function_call = 51, RULE_builtin_function = 52, - RULE_builtin_method = 53, RULE_dataType = 54, RULE_function_name = 55, - RULE_method_name = 56, RULE_configuration = 57; + RULE_component = 49, RULE_set = 50, RULE_mapping = 51, RULE_mapping_component = 52, + RULE_function_call = 53, RULE_builtin_function = 54, RULE_builtin_method = 55, + RULE_dataType = 56, RULE_function_name = 57, RULE_method_name = 58, RULE_configuration = 59; public static final String[] ruleNames = { "main", "statement_sequence", "statement", "assumeStmt", "assertStmt", "havocStmt", "symbolicStmt", "symbolicDeclarator", "directive", "repeat_struct", @@ -69,8 +69,9 @@ public class alkParser extends Parser { "shift_expression", "additive_expression", "multiplicative_expression", "unary_expression", "postfix_expression", "factor", "base_factor", "anno", "value", "scalar_value", "ref_name", "data_structure", "interval", "spec", - "array", "list", "structure", "component", "set", "function_call", "builtin_function", - "builtin_method", "dataType", "function_name", "method_name", "configuration" + "array", "list", "structure", "component", "set", "mapping", "mapping_component", + "function_call", "builtin_function", "builtin_method", "dataType", "function_name", + "method_name", "configuration" }; private static final String[] _LITERAL_NAMES = { @@ -79,12 +80,12 @@ public class alkParser extends Parser { "'exists'", "'::'", "'|->'", "'if'", "'else'", "'while'", "'do'", "'for'", "'foreach'", "'in'", "'from'", "'out'", "'havoc'", "'choose'", "'uniform'", "'repeat'", "'return'", "'success'", "'until'", "'failure'", "'continue'", - "'break'", "'emptySet'", "'emptyList'", "'emptyStructure'", "'modifies'", - "'uses'", "'include'", "'xor'", "'abs'", "'acos'", "'asin'", "'atan'", - "'cos'", "'log'", "'pi'", "'pow'", "'sin'", "'sqrt'", "'tan'", "'len'", - "'array'", "'set'", "'at'", "'belongsTo'", "'delete'", "'empty'", "'end'", - "'first'", "'float'", "'insert'", "'int'", "'boolean'", "'print'", "'popBack'", - "'popFront'", "'pushBack'", "'pushFront'", "'remove'", "'removeAllEqTo'", + "'break'", "'emptyMap'", "'emptySet'", "'emptyList'", "'emptyStructure'", + "'modifies'", "'uses'", "'include'", "'xor'", "'abs'", "'acos'", "'asin'", + "'atan'", "'cos'", "'log'", "'pi'", "'pow'", "'sin'", "'sqrt'", "'tan'", + "'len'", "'array'", "'set'", "'at'", "'belongsTo'", "'delete'", "'empty'", + "'end'", "'first'", "'float'", "'insert'", "'int'", "'boolean'", "'print'", + "'popBack'", "'popFront'", "'pushBack'", "'pushFront'", "'remove'", "'removeAllEqTo'", "'removeAt'", "'singletonSet'", "'size'", "'split'", "'topBack'", "'topFront'", "'update'", "'uniformNat'", "'flip'", "'uniformFloat'", "'uniformPerm'", "'s.t.'", "'$'", "'->'", "'#'", "'@'", "'Count'", "'U'", "'^'", "'\\'", @@ -99,21 +100,21 @@ public class alkParser extends Parser { "INVARIANT", "REQURIES", "ENSURES", "RESULT", "IMPLIES", "EQUIV", "FORALL", "EXISTS", "QUANTIFIER_SEPARATOR", "TO", "IF", "ELSE", "WHILE", "DO", "FOR", "FOREACH", "IN", "FROM", "OUT", "HAVOC", "CHOOSE", "UNIFORM", "REPEAT", - "RETURN", "SUCCESS", "UNTIL", "FAILURE", "CONTINUE", "BREAK", "EMPTYSET", - "EMPTYLIST", "EMPTYSTRUCTURE", "MODIFIES", "USES", "INCLDUE", "XOR", "ABS", - "ACOS", "ASIN", "ATAN", "COS", "LOG", "PI", "POW", "SIN", "SQRT", "TAN", - "LEN", "ARRAY", "SET", "AT", "BELONGSTO", "DELETE", "EMPTY", "END", "FIRST", - "FLOAT", "INSERT", "INTEGER", "BOOLEAN", "PRINT", "POPBACK", "POPFRONT", - "PUSHBACK", "PUSHFRONT", "REMOVE", "REMOVEALLEQTO", "REMOVEAT", "SINGLETONSET", - "SIZE", "SPLIT", "TOPBACK", "TOPFRONT", "UPDATE", "UNIFORMNAT", "FLIP", - "UNIFORMFLOAT", "UNIFORMPERM", "SOTHAT", "SYM", "ARROW", "NUMSIGN", "ANNO", - "COUNT", "UNION", "INTERSECT", "SUBTRACT", "INT", "DOUBLE", "BOOL", "ID", - "PLUSPLUS", "MINUSMINUS", "BITWISE_AND", "PLUSMOD", "MINUSMOD", "PLUSPLUSMOD", - "MINUSMINUSMOD", "LOWER", "GREATER", "LOWEREQ", "GREATEREQ", "ISEQUAL", - "NOTEQUAL", "ASSIGNMENT_OPERATOR", "MINUS", "PLUS", "MUL", "DIV", "MOD", - "LPAR", "RPAR", "LEFTSHIFT", "RIGHTSHIFT", "OR", "AND", "NOT", "SEMICOLON", - "DPOINT", "VBAR", "LCB", "RCB", "COMMA", "POINT", "LBRA", "RBRA", "QUOTE", - "QUESTION", "STRING" + "RETURN", "SUCCESS", "UNTIL", "FAILURE", "CONTINUE", "BREAK", "EMPTYMAP", + "EMPTYSET", "EMPTYLIST", "EMPTYSTRUCTURE", "MODIFIES", "USES", "INCLDUE", + "XOR", "ABS", "ACOS", "ASIN", "ATAN", "COS", "LOG", "PI", "POW", "SIN", + "SQRT", "TAN", "LEN", "ARRAY", "SET", "AT", "BELONGSTO", "DELETE", "EMPTY", + "END", "FIRST", "FLOAT", "INSERT", "INTEGER", "BOOLEAN", "PRINT", "POPBACK", + "POPFRONT", "PUSHBACK", "PUSHFRONT", "REMOVE", "REMOVEALLEQTO", "REMOVEAT", + "SINGLETONSET", "SIZE", "SPLIT", "TOPBACK", "TOPFRONT", "UPDATE", "UNIFORMNAT", + "FLIP", "UNIFORMFLOAT", "UNIFORMPERM", "SOTHAT", "SYM", "ARROW", "NUMSIGN", + "ANNO", "COUNT", "UNION", "INTERSECT", "SUBTRACT", "INT", "DOUBLE", "BOOL", + "ID", "PLUSPLUS", "MINUSMINUS", "BITWISE_AND", "PLUSMOD", "MINUSMOD", + "PLUSPLUSMOD", "MINUSMINUSMOD", "LOWER", "GREATER", "LOWEREQ", "GREATEREQ", + "ISEQUAL", "NOTEQUAL", "ASSIGNMENT_OPERATOR", "MINUS", "PLUS", "MUL", + "DIV", "MOD", "LPAR", "RPAR", "LEFTSHIFT", "RIGHTSHIFT", "OR", "AND", + "NOT", "SEMICOLON", "DPOINT", "VBAR", "LCB", "RCB", "COMMA", "POINT", + "LBRA", "RBRA", "QUOTE", "QUESTION", "STRING" }; public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); @@ -196,17 +197,17 @@ public final MainContext main() throws RecognitionException { _localctx = new StartPointContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(117); + setState(121); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (ASSERT - 4)) | (1L << (ASSUME - 4)) | (1L << (SYMBOLIC - 4)) | (1L << (RESULT - 4)) | (1L << (FORALL - 4)) | (1L << (EXISTS - 4)) | (1L << (IF - 4)) | (1L << (WHILE - 4)) | (1L << (DO - 4)) | (1L << (FOR - 4)) | (1L << (FOREACH - 4)) | (1L << (HAVOC - 4)) | (1L << (CHOOSE - 4)) | (1L << (UNIFORM - 4)) | (1L << (REPEAT - 4)) | (1L << (RETURN - 4)) | (1L << (SUCCESS - 4)) | (1L << (FAILURE - 4)) | (1L << (CONTINUE - 4)) | (1L << (BREAK - 4)) | (1L << (EMPTYSET - 4)) | (1L << (EMPTYLIST - 4)) | (1L << (EMPTYSTRUCTURE - 4)) | (1L << (ABS - 4)) | (1L << (ACOS - 4)) | (1L << (ASIN - 4)) | (1L << (ATAN - 4)) | (1L << (COS - 4)) | (1L << (LOG - 4)) | (1L << (PI - 4)) | (1L << (POW - 4)) | (1L << (SIN - 4)) | (1L << (SQRT - 4)) | (1L << (TAN - 4)) | (1L << (LEN - 4)) | (1L << (FLOAT - 4)) | (1L << (INTEGER - 4)) | (1L << (PRINT - 4)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (NUMSIGN - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSERT) | (1L << ASSUME) | (1L << SYMBOLIC) | (1L << RESULT) | (1L << FORALL) | (1L << EXISTS) | (1L << IF) | (1L << WHILE) | (1L << DO) | (1L << FOR) | (1L << FOREACH) | (1L << HAVOC) | (1L << CHOOSE) | (1L << UNIFORM) | (1L << REPEAT) | (1L << RETURN) | (1L << SUCCESS) | (1L << FAILURE) | (1L << CONTINUE) | (1L << BREAK) | (1L << EMPTYMAP) | (1L << EMPTYSET) | (1L << EMPTYLIST) | (1L << EMPTYSTRUCTURE) | (1L << ABS) | (1L << ACOS) | (1L << ASIN) | (1L << ATAN) | (1L << COS) | (1L << LOG) | (1L << PI) | (1L << POW) | (1L << SIN) | (1L << SQRT) | (1L << TAN) | (1L << LEN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (FLOAT - 64)) | (1L << (INTEGER - 64)) | (1L << (PRINT - 64)) | (1L << (SINGLETONSET - 64)) | (1L << (UNIFORMNAT - 64)) | (1L << (FLIP - 64)) | (1L << (UNIFORMFLOAT - 64)) | (1L << (UNIFORMPERM - 64)) | (1L << (SYM - 64)) | (1L << (NUMSIGN - 64)) | (1L << (ANNO - 64)) | (1L << (INT - 64)) | (1L << (DOUBLE - 64)) | (1L << (BOOL - 64)) | (1L << (ID - 64)) | (1L << (PLUSPLUS - 64)) | (1L << (MINUSMINUS - 64)) | (1L << (PLUSPLUSMOD - 64)) | (1L << (MINUSMINUSMOD - 64)) | (1L << (LOWER - 64)) | (1L << (MINUS - 64)) | (1L << (PLUS - 64)) | (1L << (MUL - 64)) | (1L << (LPAR - 64)) | (1L << (NOT - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LCB - 128)) | (1L << (LBRA - 128)) | (1L << (QUESTION - 128)) | (1L << (STRING - 128)))) != 0)) { { - setState(116); + setState(120); statement_sequence(); } } - setState(119); + setState(123); match(EOF); } } @@ -255,20 +256,20 @@ public final Statement_sequenceContext statement_sequence() throws RecognitionEx _localctx = new StatementSeqContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(122); + setState(126); _errHandler.sync(this); _la = _input.LA(1); do { { { - setState(121); + setState(125); statement(); } } - setState(124); + setState(128); _errHandler.sync(this); _la = _input.LA(1); - } while ( ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (ASSERT - 4)) | (1L << (ASSUME - 4)) | (1L << (SYMBOLIC - 4)) | (1L << (RESULT - 4)) | (1L << (FORALL - 4)) | (1L << (EXISTS - 4)) | (1L << (IF - 4)) | (1L << (WHILE - 4)) | (1L << (DO - 4)) | (1L << (FOR - 4)) | (1L << (FOREACH - 4)) | (1L << (HAVOC - 4)) | (1L << (CHOOSE - 4)) | (1L << (UNIFORM - 4)) | (1L << (REPEAT - 4)) | (1L << (RETURN - 4)) | (1L << (SUCCESS - 4)) | (1L << (FAILURE - 4)) | (1L << (CONTINUE - 4)) | (1L << (BREAK - 4)) | (1L << (EMPTYSET - 4)) | (1L << (EMPTYLIST - 4)) | (1L << (EMPTYSTRUCTURE - 4)) | (1L << (ABS - 4)) | (1L << (ACOS - 4)) | (1L << (ASIN - 4)) | (1L << (ATAN - 4)) | (1L << (COS - 4)) | (1L << (LOG - 4)) | (1L << (PI - 4)) | (1L << (POW - 4)) | (1L << (SIN - 4)) | (1L << (SQRT - 4)) | (1L << (TAN - 4)) | (1L << (LEN - 4)) | (1L << (FLOAT - 4)) | (1L << (INTEGER - 4)) | (1L << (PRINT - 4)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (NUMSIGN - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0) ); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSERT) | (1L << ASSUME) | (1L << SYMBOLIC) | (1L << RESULT) | (1L << FORALL) | (1L << EXISTS) | (1L << IF) | (1L << WHILE) | (1L << DO) | (1L << FOR) | (1L << FOREACH) | (1L << HAVOC) | (1L << CHOOSE) | (1L << UNIFORM) | (1L << REPEAT) | (1L << RETURN) | (1L << SUCCESS) | (1L << FAILURE) | (1L << CONTINUE) | (1L << BREAK) | (1L << EMPTYMAP) | (1L << EMPTYSET) | (1L << EMPTYLIST) | (1L << EMPTYSTRUCTURE) | (1L << ABS) | (1L << ACOS) | (1L << ASIN) | (1L << ATAN) | (1L << COS) | (1L << LOG) | (1L << PI) | (1L << POW) | (1L << SIN) | (1L << SQRT) | (1L << TAN) | (1L << LEN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (FLOAT - 64)) | (1L << (INTEGER - 64)) | (1L << (PRINT - 64)) | (1L << (SINGLETONSET - 64)) | (1L << (UNIFORMNAT - 64)) | (1L << (FLIP - 64)) | (1L << (UNIFORMFLOAT - 64)) | (1L << (UNIFORMPERM - 64)) | (1L << (SYM - 64)) | (1L << (NUMSIGN - 64)) | (1L << (ANNO - 64)) | (1L << (INT - 64)) | (1L << (DOUBLE - 64)) | (1L << (BOOL - 64)) | (1L << (ID - 64)) | (1L << (PLUSPLUS - 64)) | (1L << (MINUSMINUS - 64)) | (1L << (PLUSPLUSMOD - 64)) | (1L << (MINUSMINUSMOD - 64)) | (1L << (LOWER - 64)) | (1L << (MINUS - 64)) | (1L << (PLUS - 64)) | (1L << (MUL - 64)) | (1L << (LPAR - 64)) | (1L << (NOT - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LCB - 128)) | (1L << (LBRA - 128)) | (1L << (QUESTION - 128)) | (1L << (STRING - 128)))) != 0) ); } } catch (RecognitionException re) { @@ -525,14 +526,14 @@ public final StatementContext statement() throws RecognitionException { enterRule(_localctx, 4, RULE_statement); int _la; try { - setState(170); + setState(174); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { case 1: _localctx = new ToFunctionDeclContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(126); + setState(130); function_decl(); } break; @@ -540,19 +541,19 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ReturnStmtContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(127); + setState(131); match(RETURN); - setState(129); + setState(133); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0)) { { - setState(128); + setState(132); expression(); } } - setState(131); + setState(135); match(SEMICOLON); } break; @@ -560,9 +561,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToChooseStmtContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(132); + setState(136); choose(); - setState(133); + setState(137); match(SEMICOLON); } break; @@ -570,9 +571,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new SuccessContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(135); + setState(139); match(SUCCESS); - setState(136); + setState(140); match(SEMICOLON); } break; @@ -580,9 +581,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new FailureContext(_localctx); enterOuterAlt(_localctx, 5); { - setState(137); + setState(141); match(FAILURE); - setState(138); + setState(142); match(SEMICOLON); } break; @@ -590,9 +591,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ContinueStmtContext(_localctx); enterOuterAlt(_localctx, 6); { - setState(139); + setState(143); match(CONTINUE); - setState(140); + setState(144); match(SEMICOLON); } break; @@ -600,9 +601,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new BreakStmtContext(_localctx); enterOuterAlt(_localctx, 7); { - setState(141); + setState(145); match(BREAK); - setState(142); + setState(146); match(SEMICOLON); } break; @@ -610,7 +611,7 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToBlockContext(_localctx); enterOuterAlt(_localctx, 8); { - setState(143); + setState(147); statement_block(); } break; @@ -618,7 +619,7 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToDirectiveContext(_localctx); enterOuterAlt(_localctx, 9); { - setState(144); + setState(148); directive(); } break; @@ -626,9 +627,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToRepeatContext(_localctx); enterOuterAlt(_localctx, 10); { - setState(145); + setState(149); repeat_struct(); - setState(146); + setState(150); match(SEMICOLON); } break; @@ -636,7 +637,7 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToWhileContext(_localctx); enterOuterAlt(_localctx, 11); { - setState(148); + setState(152); while_struct(); } break; @@ -644,9 +645,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToDoWhileContext(_localctx); enterOuterAlt(_localctx, 12); { - setState(149); + setState(153); do_while_struct(); - setState(150); + setState(154); match(SEMICOLON); } break; @@ -654,7 +655,7 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToIfContext(_localctx); enterOuterAlt(_localctx, 13); { - setState(152); + setState(156); if_struct(); } break; @@ -662,7 +663,7 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToForContext(_localctx); enterOuterAlt(_localctx, 14); { - setState(153); + setState(157); for_struct(); } break; @@ -670,7 +671,7 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToForEachContext(_localctx); enterOuterAlt(_localctx, 15); { - setState(154); + setState(158); foreach_struct(); } break; @@ -678,9 +679,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ExpressionStmtContext(_localctx); enterOuterAlt(_localctx, 16); { - setState(155); + setState(159); expression(); - setState(156); + setState(160); match(SEMICOLON); } break; @@ -688,9 +689,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new SymbolicDeclStmtContext(_localctx); enterOuterAlt(_localctx, 17); { - setState(158); + setState(162); symbolicStmt(); - setState(159); + setState(163); match(SEMICOLON); } break; @@ -698,9 +699,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToHavocStmtContext(_localctx); enterOuterAlt(_localctx, 18); { - setState(161); + setState(165); havocStmt(); - setState(162); + setState(166); match(SEMICOLON); } break; @@ -708,9 +709,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToAssumeStmtContext(_localctx); enterOuterAlt(_localctx, 19); { - setState(164); + setState(168); assumeStmt(); - setState(165); + setState(169); match(SEMICOLON); } break; @@ -718,9 +719,9 @@ public final StatementContext statement() throws RecognitionException { _localctx = new ToAssertStmtContext(_localctx); enterOuterAlt(_localctx, 20); { - setState(167); + setState(171); assertStmt(); - setState(168); + setState(172); match(SEMICOLON); } break; @@ -768,9 +769,9 @@ public final AssumeStmtContext assumeStmt() throws RecognitionException { _localctx = new AssumeContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(172); + setState(176); match(ASSUME); - setState(173); + setState(177); expression(); } } @@ -816,9 +817,9 @@ public final AssertStmtContext assertStmt() throws RecognitionException { _localctx = new AssertContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(175); + setState(179); match(ASSERT); - setState(176); + setState(180); expression(); } } @@ -870,23 +871,23 @@ public final HavocStmtContext havocStmt() throws RecognitionException { _localctx = new HavocContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(178); + setState(182); match(HAVOC); - setState(179); + setState(183); match(ID); - setState(184); + setState(188); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(180); + setState(184); match(COMMA); - setState(181); + setState(185); match(ID); } } - setState(186); + setState(190); _errHandler.sync(this); _la = _input.LA(1); } @@ -942,23 +943,23 @@ public final SymbolicStmtContext symbolicStmt() throws RecognitionException { _localctx = new SymbolicDeclsContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(187); + setState(191); match(SYMBOLIC); - setState(188); + setState(192); symbolicDeclarator(); - setState(193); + setState(197); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(189); + setState(193); match(COMMA); - setState(190); + setState(194); symbolicDeclarator(); } } - setState(195); + setState(199); _errHandler.sync(this); _la = _input.LA(1); } @@ -1008,13 +1009,13 @@ public final SymbolicDeclaratorContext symbolicDeclarator() throws RecognitionEx _localctx = new SymbolicIdDeclContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(196); + setState(200); match(SYM); - setState(197); + setState(201); match(ID); - setState(198); + setState(202); match(DPOINT); - setState(199); + setState(203); dataType(); } } @@ -1059,11 +1060,11 @@ public final DirectiveContext directive() throws RecognitionException { _localctx = new IncludeContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(201); + setState(205); match(NUMSIGN); - setState(202); + setState(206); match(INCLDUE); - setState(203); + setState(207); match(STRING); } } @@ -1115,17 +1116,17 @@ public final Repeat_structContext repeat_struct() throws RecognitionException { _localctx = new RepeatStructureContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(205); + setState(209); match(REPEAT); - setState(206); + setState(210); statement(); - setState(207); + setState(211); match(UNTIL); - setState(208); + setState(212); match(LPAR); - setState(209); + setState(213); expression(); - setState(210); + setState(214); match(RPAR); } } @@ -1173,19 +1174,19 @@ public final Statement_blockContext statement_block() throws RecognitionExceptio _localctx = new BlockContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(212); + setState(216); match(LCB); - setState(214); + setState(218); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (ASSERT - 4)) | (1L << (ASSUME - 4)) | (1L << (SYMBOLIC - 4)) | (1L << (RESULT - 4)) | (1L << (FORALL - 4)) | (1L << (EXISTS - 4)) | (1L << (IF - 4)) | (1L << (WHILE - 4)) | (1L << (DO - 4)) | (1L << (FOR - 4)) | (1L << (FOREACH - 4)) | (1L << (HAVOC - 4)) | (1L << (CHOOSE - 4)) | (1L << (UNIFORM - 4)) | (1L << (REPEAT - 4)) | (1L << (RETURN - 4)) | (1L << (SUCCESS - 4)) | (1L << (FAILURE - 4)) | (1L << (CONTINUE - 4)) | (1L << (BREAK - 4)) | (1L << (EMPTYSET - 4)) | (1L << (EMPTYLIST - 4)) | (1L << (EMPTYSTRUCTURE - 4)) | (1L << (ABS - 4)) | (1L << (ACOS - 4)) | (1L << (ASIN - 4)) | (1L << (ATAN - 4)) | (1L << (COS - 4)) | (1L << (LOG - 4)) | (1L << (PI - 4)) | (1L << (POW - 4)) | (1L << (SIN - 4)) | (1L << (SQRT - 4)) | (1L << (TAN - 4)) | (1L << (LEN - 4)) | (1L << (FLOAT - 4)) | (1L << (INTEGER - 4)) | (1L << (PRINT - 4)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (NUMSIGN - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSERT) | (1L << ASSUME) | (1L << SYMBOLIC) | (1L << RESULT) | (1L << FORALL) | (1L << EXISTS) | (1L << IF) | (1L << WHILE) | (1L << DO) | (1L << FOR) | (1L << FOREACH) | (1L << HAVOC) | (1L << CHOOSE) | (1L << UNIFORM) | (1L << REPEAT) | (1L << RETURN) | (1L << SUCCESS) | (1L << FAILURE) | (1L << CONTINUE) | (1L << BREAK) | (1L << EMPTYMAP) | (1L << EMPTYSET) | (1L << EMPTYLIST) | (1L << EMPTYSTRUCTURE) | (1L << ABS) | (1L << ACOS) | (1L << ASIN) | (1L << ATAN) | (1L << COS) | (1L << LOG) | (1L << PI) | (1L << POW) | (1L << SIN) | (1L << SQRT) | (1L << TAN) | (1L << LEN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (FLOAT - 64)) | (1L << (INTEGER - 64)) | (1L << (PRINT - 64)) | (1L << (SINGLETONSET - 64)) | (1L << (UNIFORMNAT - 64)) | (1L << (FLIP - 64)) | (1L << (UNIFORMFLOAT - 64)) | (1L << (UNIFORMPERM - 64)) | (1L << (SYM - 64)) | (1L << (NUMSIGN - 64)) | (1L << (ANNO - 64)) | (1L << (INT - 64)) | (1L << (DOUBLE - 64)) | (1L << (BOOL - 64)) | (1L << (ID - 64)) | (1L << (PLUSPLUS - 64)) | (1L << (MINUSMINUS - 64)) | (1L << (PLUSPLUSMOD - 64)) | (1L << (MINUSMINUSMOD - 64)) | (1L << (LOWER - 64)) | (1L << (MINUS - 64)) | (1L << (PLUS - 64)) | (1L << (MUL - 64)) | (1L << (LPAR - 64)) | (1L << (NOT - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LCB - 128)) | (1L << (LBRA - 128)) | (1L << (QUESTION - 128)) | (1L << (STRING - 128)))) != 0)) { { - setState(213); + setState(217); statement_sequence(); } } - setState(216); + setState(220); match(RCB); } } @@ -1250,29 +1251,29 @@ public final ChooseContext choose() throws RecognitionException { enterRule(_localctx, 22, RULE_choose); int _la; try { - setState(231); + setState(235); _errHandler.sync(this); switch (_input.LA(1)) { case CHOOSE: _localctx = new ChooseStmtContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(218); + setState(222); match(CHOOSE); - setState(219); + setState(223); expression(); - setState(220); + setState(224); match(FROM); - setState(221); + setState(225); expression(); - setState(224); + setState(228); _errHandler.sync(this); _la = _input.LA(1); if (_la==SOTHAT) { { - setState(222); + setState(226); match(SOTHAT); - setState(223); + setState(227); expression(); } } @@ -1283,13 +1284,13 @@ public final ChooseContext choose() throws RecognitionException { _localctx = new UniformStmtContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(226); + setState(230); match(UNIFORM); - setState(227); + setState(231); expression(); - setState(228); + setState(232); match(FROM); - setState(229); + setState(233); expression(); } break; @@ -1362,36 +1363,36 @@ public final While_structContext while_struct() throws RecognitionException { _localctx = new WhileStructureContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(233); + setState(237); match(WHILE); - setState(234); + setState(238); match(LPAR); - setState(235); + setState(239); expression(); - setState(236); + setState(240); match(RPAR); - setState(241); + setState(245); _errHandler.sync(this); _la = _input.LA(1); while (_la==INVARIANT) { { { - setState(237); + setState(241); match(INVARIANT); - setState(238); + setState(242); expression(); } } - setState(243); + setState(247); _errHandler.sync(this); _la = _input.LA(1); } - setState(253); + setState(257); _errHandler.sync(this); _la = _input.LA(1); if (_la==MODIFIES || _la==USES) { { - setState(244); + setState(248); _la = _input.LA(1); if ( !(_la==MODIFIES || _la==USES) ) { _errHandler.recoverInline(this); @@ -1401,28 +1402,28 @@ public final While_structContext while_struct() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(245); + setState(249); match(ID); - setState(250); + setState(254); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(246); + setState(250); match(COMMA); - setState(247); + setState(251); match(ID); } } - setState(252); + setState(256); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(255); + setState(259); statement(); } } @@ -1474,17 +1475,17 @@ public final Do_while_structContext do_while_struct() throws RecognitionExceptio _localctx = new DoWhileStructureContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(257); + setState(261); match(DO); - setState(258); + setState(262); statement(); - setState(259); + setState(263); match(WHILE); - setState(260); + setState(264); match(LPAR); - setState(261); + setState(265); expression(); - setState(262); + setState(266); match(RPAR); } } @@ -1539,24 +1540,24 @@ public final If_structContext if_struct() throws RecognitionException { _localctx = new IfStructureContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(264); + setState(268); match(IF); - setState(265); + setState(269); match(LPAR); - setState(266); + setState(270); expression(); - setState(267); + setState(271); match(RPAR); - setState(268); + setState(272); statement(); - setState(271); + setState(275); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { case 1: { - setState(269); + setState(273); match(ELSE); - setState(270); + setState(274); statement(); } break; @@ -1617,23 +1618,23 @@ public final For_structContext for_struct() throws RecognitionException { _localctx = new ForStructureContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(273); + setState(277); match(FOR); - setState(274); + setState(278); match(LPAR); - setState(275); + setState(279); expression(); - setState(276); + setState(280); match(SEMICOLON); - setState(277); + setState(281); expression(); - setState(278); + setState(282); match(SEMICOLON); - setState(279); + setState(283); expression(); - setState(280); + setState(284); match(RPAR); - setState(281); + setState(285); statement(); } } @@ -1684,15 +1685,15 @@ public final Foreach_structContext foreach_struct() throws RecognitionException _localctx = new ForEachStructureContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(283); + setState(287); match(FOREACH); - setState(284); + setState(288); match(ID); - setState(285); + setState(289); match(FROM); - setState(286); + setState(290); expression(); - setState(287); + setState(291); statement(); } } @@ -1780,56 +1781,56 @@ public final Function_declContext function_decl() throws RecognitionException { _localctx = new FunctionDeclContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(289); + setState(293); match(ID); - setState(290); + setState(294); match(LPAR); - setState(299); + setState(303); _errHandler.sync(this); _la = _input.LA(1); if (_la==OUT || _la==ID) { { - setState(291); + setState(295); param(); - setState(296); + setState(300); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(292); + setState(296); match(COMMA); - setState(293); + setState(297); param(); } } - setState(298); + setState(302); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(301); + setState(305); match(RPAR); - setState(304); + setState(308); _errHandler.sync(this); _la = _input.LA(1); if (_la==DPOINT) { { - setState(302); + setState(306); match(DPOINT); - setState(303); + setState(307); dataType(); } } - setState(315); + setState(319); _errHandler.sync(this); _la = _input.LA(1); if (_la==MODIFIES || _la==USES) { { - setState(306); + setState(310); _la = _input.LA(1); if ( !(_la==MODIFIES || _la==USES) ) { _errHandler.recoverInline(this); @@ -1839,60 +1840,60 @@ public final Function_declContext function_decl() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(307); + setState(311); match(ID); - setState(312); + setState(316); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(308); + setState(312); match(COMMA); - setState(309); + setState(313); match(ID); } } - setState(314); + setState(318); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(321); + setState(325); _errHandler.sync(this); _la = _input.LA(1); while (_la==REQURIES) { { { - setState(317); + setState(321); match(REQURIES); - setState(318); + setState(322); req_expression(); } } - setState(323); + setState(327); _errHandler.sync(this); _la = _input.LA(1); } - setState(328); + setState(332); _errHandler.sync(this); _la = _input.LA(1); while (_la==ENSURES) { { { - setState(324); + setState(328); match(ENSURES); - setState(325); + setState(329); ens_expression(); } } - setState(330); + setState(334); _errHandler.sync(this); _la = _input.LA(1); } - setState(331); + setState(335); statement_block(); } } @@ -1937,7 +1938,7 @@ public final Req_expressionContext req_expression() throws RecognitionException _localctx = new ReqExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(333); + setState(337); expression(); } } @@ -1982,7 +1983,7 @@ public final Ens_expressionContext ens_expression() throws RecognitionException _localctx = new EnsExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(335); + setState(339); expression(); } } @@ -2031,26 +2032,26 @@ public final ParamContext param() throws RecognitionException { _localctx = new ParamDefinitionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(338); + setState(342); _errHandler.sync(this); _la = _input.LA(1); if (_la==OUT) { { - setState(337); + setState(341); match(OUT); } } - setState(340); + setState(344); match(ID); - setState(343); + setState(347); _errHandler.sync(this); _la = _input.LA(1); if (_la==DPOINT) { { - setState(341); + setState(345); match(DPOINT); - setState(342); + setState(346); dataType(); } } @@ -2188,18 +2189,18 @@ public final ExpressionContext expression() throws RecognitionException { enterRule(_localctx, 42, RULE_expression); int _la; try { - setState(386); + setState(390); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) { case 1: _localctx = new ImpliesExprContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(345); + setState(349); assign_expression(); - setState(346); + setState(350); match(IMPLIES); - setState(347); + setState(351); expression(); } break; @@ -2207,11 +2208,11 @@ public final ExpressionContext expression() throws RecognitionException { _localctx = new EquivExprContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(349); + setState(353); assign_expression(); - setState(350); + setState(354); match(EQUIV); - setState(351); + setState(355); expression(); } break; @@ -2219,39 +2220,39 @@ public final ExpressionContext expression() throws RecognitionException { _localctx = new ForallExprContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(353); + setState(357); match(FORALL); { - setState(354); + setState(358); match(ID); - setState(355); + setState(359); match(DPOINT); - setState(356); + setState(360); dataType(); - setState(363); + setState(367); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(357); + setState(361); match(COMMA); - setState(358); + setState(362); match(ID); - setState(359); + setState(363); match(DPOINT); - setState(360); + setState(364); dataType(); } } - setState(365); + setState(369); _errHandler.sync(this); _la = _input.LA(1); } } - setState(366); + setState(370); match(QUANTIFIER_SEPARATOR); - setState(367); + setState(371); expression(); } break; @@ -2259,39 +2260,39 @@ public final ExpressionContext expression() throws RecognitionException { _localctx = new ExistsExprContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(369); + setState(373); match(EXISTS); { - setState(370); + setState(374); match(ID); - setState(371); + setState(375); match(DPOINT); - setState(372); + setState(376); dataType(); - setState(379); + setState(383); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(373); + setState(377); match(COMMA); - setState(374); + setState(378); match(ID); - setState(375); + setState(379); match(DPOINT); - setState(376); + setState(380); dataType(); } } - setState(381); + setState(385); _errHandler.sync(this); _la = _input.LA(1); } } - setState(382); + setState(386); match(QUANTIFIER_SEPARATOR); - setState(383); + setState(387); expression(); } break; @@ -2299,7 +2300,7 @@ public final ExpressionContext expression() throws RecognitionException { _localctx = new FolToExprContext(_localctx); enterOuterAlt(_localctx, 5); { - setState(385); + setState(389); assign_expression(); } break; @@ -2358,18 +2359,18 @@ public final Assign_expressionContext assign_expression() throws RecognitionExce Assign_expressionContext _localctx = new Assign_expressionContext(_ctx, getState()); enterRule(_localctx, 44, RULE_assign_expression); try { - setState(393); + setState(397); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { case 1: _localctx = new AssignExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(388); + setState(392); factor(0); - setState(389); + setState(393); match(ASSIGNMENT_OPERATOR); - setState(390); + setState(394); expression(); } break; @@ -2377,7 +2378,7 @@ public final Assign_expressionContext assign_expression() throws RecognitionExce _localctx = new ToConditionalExprContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(392); + setState(396); conditional_expression(); } break; @@ -2432,20 +2433,20 @@ public final Conditional_expressionContext conditional_expression() throws Recog _localctx = new ConditionalExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(395); + setState(399); logical_or_expression(); - setState(401); + setState(405); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { case 1: { - setState(396); + setState(400); match(QUESTION); - setState(397); + setState(401); expression(); - setState(398); + setState(402); match(DPOINT); - setState(399); + setState(403); expression(); } break; @@ -2501,21 +2502,21 @@ public final Logical_or_expressionContext logical_or_expression() throws Recogni _localctx = new LogicalOrExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(403); + setState(407); logical_and_expression(); - setState(408); + setState(412); _errHandler.sync(this); _la = _input.LA(1); while (_la==OR) { { { - setState(404); + setState(408); match(OR); - setState(405); + setState(409); logical_and_expression(); } } - setState(410); + setState(414); _errHandler.sync(this); _la = _input.LA(1); } @@ -2570,21 +2571,21 @@ public final Logical_and_expressionContext logical_and_expression() throws Recog _localctx = new LogicalAndExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(411); + setState(415); in_expression(); - setState(416); + setState(420); _errHandler.sync(this); _la = _input.LA(1); while (_la==AND) { { { - setState(412); + setState(416); match(AND); - setState(413); + setState(417); in_expression(); } } - setState(418); + setState(422); _errHandler.sync(this); _la = _input.LA(1); } @@ -2639,21 +2640,21 @@ public final In_expressionContext in_expression() throws RecognitionException { _localctx = new InExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(419); + setState(423); equality_expression(); - setState(424); + setState(428); _errHandler.sync(this); _la = _input.LA(1); while (_la==IN) { { { - setState(420); + setState(424); match(IN); - setState(421); + setState(425); equality_expression(); } } - setState(426); + setState(430); _errHandler.sync(this); _la = _input.LA(1); } @@ -2712,15 +2713,15 @@ public final Equality_expressionContext equality_expression() throws Recognition _localctx = new EqualityExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(427); + setState(431); relational_expression(); - setState(432); + setState(436); _errHandler.sync(this); _la = _input.LA(1); while (_la==ISEQUAL || _la==NOTEQUAL) { { { - setState(428); + setState(432); _la = _input.LA(1); if ( !(_la==ISEQUAL || _la==NOTEQUAL) ) { _errHandler.recoverInline(this); @@ -2730,11 +2731,11 @@ public final Equality_expressionContext equality_expression() throws Recognition _errHandler.reportMatch(this); consume(); } - setState(429); + setState(433); relational_expression(); } } - setState(434); + setState(438); _errHandler.sync(this); _la = _input.LA(1); } @@ -2802,18 +2803,18 @@ public final Relational_expressionContext relational_expression() throws Recogni _localctx = new RelationalExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(435); + setState(439); set_expression(); - setState(440); + setState(444); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,31,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(436); + setState(440); _la = _input.LA(1); - if ( !(((((_la - 105)) & ~0x3f) == 0 && ((1L << (_la - 105)) & ((1L << (LOWER - 105)) | (1L << (GREATER - 105)) | (1L << (LOWEREQ - 105)) | (1L << (GREATEREQ - 105)))) != 0)) ) { + if ( !(((((_la - 106)) & ~0x3f) == 0 && ((1L << (_la - 106)) & ((1L << (LOWER - 106)) | (1L << (GREATER - 106)) | (1L << (LOWEREQ - 106)) | (1L << (GREATEREQ - 106)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -2821,12 +2822,12 @@ public final Relational_expressionContext relational_expression() throws Recogni _errHandler.reportMatch(this); consume(); } - setState(437); + setState(441); set_expression(); } } } - setState(442); + setState(446); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,31,_ctx); } @@ -2889,17 +2890,17 @@ public final Set_expressionContext set_expression() throws RecognitionException _localctx = new SetExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(443); + setState(447); bitwise_or(); - setState(448); + setState(452); _errHandler.sync(this); _la = _input.LA(1); - while (((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (UNION - 91)) | (1L << (INTERSECT - 91)) | (1L << (SUBTRACT - 91)))) != 0)) { + while (((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (UNION - 92)) | (1L << (INTERSECT - 92)) | (1L << (SUBTRACT - 92)))) != 0)) { { { - setState(444); + setState(448); _la = _input.LA(1); - if ( !(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (UNION - 91)) | (1L << (INTERSECT - 91)) | (1L << (SUBTRACT - 91)))) != 0)) ) { + if ( !(((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (UNION - 92)) | (1L << (INTERSECT - 92)) | (1L << (SUBTRACT - 92)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -2907,11 +2908,11 @@ public final Set_expressionContext set_expression() throws RecognitionException _errHandler.reportMatch(this); consume(); } - setState(445); + setState(449); bitwise_or(); } } - setState(450); + setState(454); _errHandler.sync(this); _la = _input.LA(1); } @@ -2971,16 +2972,16 @@ public final Bitwise_orContext bitwise_or() throws RecognitionException { _localctx = new BitwiseOrExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(451); + setState(455); bitwise_and(); - setState(456); + setState(460); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,33,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(452); + setState(456); _la = _input.LA(1); if ( !(_la==XOR || _la==VBAR) ) { _errHandler.recoverInline(this); @@ -2990,12 +2991,12 @@ public final Bitwise_orContext bitwise_or() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(453); + setState(457); bitwise_and(); } } } - setState(458); + setState(462); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,33,_ctx); } @@ -3050,21 +3051,21 @@ public final Bitwise_andContext bitwise_and() throws RecognitionException { _localctx = new BitwiseAndExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(459); + setState(463); shift_expression(); - setState(464); + setState(468); _errHandler.sync(this); _la = _input.LA(1); while (_la==BITWISE_AND) { { { - setState(460); + setState(464); match(BITWISE_AND); - setState(461); + setState(465); shift_expression(); } } - setState(466); + setState(470); _errHandler.sync(this); _la = _input.LA(1); } @@ -3123,15 +3124,15 @@ public final Shift_expressionContext shift_expression() throws RecognitionExcept _localctx = new ShiftExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(467); + setState(471); additive_expression(); - setState(472); + setState(476); _errHandler.sync(this); _la = _input.LA(1); while (_la==LEFTSHIFT || _la==RIGHTSHIFT) { { { - setState(468); + setState(472); _la = _input.LA(1); if ( !(_la==LEFTSHIFT || _la==RIGHTSHIFT) ) { _errHandler.recoverInline(this); @@ -3141,11 +3142,11 @@ public final Shift_expressionContext shift_expression() throws RecognitionExcept _errHandler.reportMatch(this); consume(); } - setState(469); + setState(473); additive_expression(); } } - setState(474); + setState(478); _errHandler.sync(this); _la = _input.LA(1); } @@ -3213,18 +3214,18 @@ public final Additive_expressionContext additive_expression() throws Recognition _localctx = new AdditiveExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(475); + setState(479); multiplicative_expression(); - setState(480); + setState(484); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,36,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(476); + setState(480); _la = _input.LA(1); - if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (PLUSMOD - 101)) | (1L << (MINUSMOD - 101)) | (1L << (MINUS - 101)) | (1L << (PLUS - 101)))) != 0)) ) { + if ( !(((((_la - 102)) & ~0x3f) == 0 && ((1L << (_la - 102)) & ((1L << (PLUSMOD - 102)) | (1L << (MINUSMOD - 102)) | (1L << (MINUS - 102)) | (1L << (PLUS - 102)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -3232,12 +3233,12 @@ public final Additive_expressionContext additive_expression() throws Recognition _errHandler.reportMatch(this); consume(); } - setState(477); + setState(481); multiplicative_expression(); } } } - setState(482); + setState(486); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,36,_ctx); } @@ -3301,18 +3302,18 @@ public final Multiplicative_expressionContext multiplicative_expression() throws _localctx = new MultiplicativeExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(483); + setState(487); unary_expression(); - setState(488); + setState(492); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,37,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(484); + setState(488); _la = _input.LA(1); - if ( !(((((_la - 114)) & ~0x3f) == 0 && ((1L << (_la - 114)) & ((1L << (MUL - 114)) | (1L << (DIV - 114)) | (1L << (MOD - 114)))) != 0)) ) { + if ( !(((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & ((1L << (MUL - 115)) | (1L << (DIV - 115)) | (1L << (MOD - 115)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -3320,12 +3321,12 @@ public final Multiplicative_expressionContext multiplicative_expression() throws _errHandler.reportMatch(this); consume(); } - setState(485); + setState(489); unary_expression(); } } } - setState(490); + setState(494); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,37,_ctx); } @@ -3400,7 +3401,7 @@ public final Unary_expressionContext unary_expression() throws RecognitionExcept enterRule(_localctx, 70, RULE_unary_expression); int _la; try { - setState(496); + setState(500); _errHandler.sync(this); switch (_input.LA(1)) { case PLUSPLUS: @@ -3410,9 +3411,9 @@ public final Unary_expressionContext unary_expression() throws RecognitionExcept _localctx = new PrefixExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(491); + setState(495); _la = _input.LA(1); - if ( !(((((_la - 98)) & ~0x3f) == 0 && ((1L << (_la - 98)) & ((1L << (PLUSPLUS - 98)) | (1L << (MINUSMINUS - 98)) | (1L << (PLUSPLUSMOD - 98)) | (1L << (MINUSMINUSMOD - 98)))) != 0)) ) { + if ( !(((((_la - 99)) & ~0x3f) == 0 && ((1L << (_la - 99)) & ((1L << (PLUSPLUS - 99)) | (1L << (MINUSMINUS - 99)) | (1L << (PLUSPLUSMOD - 99)) | (1L << (MINUSMINUSMOD - 99)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -3420,7 +3421,7 @@ public final Unary_expressionContext unary_expression() throws RecognitionExcept _errHandler.reportMatch(this); consume(); } - setState(492); + setState(496); unary_expression(); } break; @@ -3431,9 +3432,9 @@ public final Unary_expressionContext unary_expression() throws RecognitionExcept _localctx = new UnaryExpressionContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(493); + setState(497); _la = _input.LA(1); - if ( !(((((_la - 112)) & ~0x3f) == 0 && ((1L << (_la - 112)) & ((1L << (MINUS - 112)) | (1L << (PLUS - 112)) | (1L << (MUL - 112)) | (1L << (NOT - 112)))) != 0)) ) { + if ( !(((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & ((1L << (MINUS - 113)) | (1L << (PLUS - 113)) | (1L << (MUL - 113)) | (1L << (NOT - 113)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -3441,11 +3442,12 @@ public final Unary_expressionContext unary_expression() throws RecognitionExcept _errHandler.reportMatch(this); consume(); } - setState(494); + setState(498); unary_expression(); } break; case RESULT: + case EMPTYMAP: case EMPTYSET: case EMPTYLIST: case EMPTYSTRUCTURE: @@ -3484,7 +3486,7 @@ public final Unary_expressionContext unary_expression() throws RecognitionExcept _localctx = new ToPostfixExpressionContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(495); + setState(499); postfix_expression(); } break; @@ -3543,16 +3545,16 @@ public final Postfix_expressionContext postfix_expression() throws RecognitionEx _localctx = new PostfixExpressionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(498); - factor(0); setState(502); + factor(0); + setState(506); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,39,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(499); + setState(503); _la = _input.LA(1); if ( !(_la==PLUSPLUS || _la==MINUSMINUS) ) { _errHandler.recoverInline(this); @@ -3565,7 +3567,7 @@ public final Postfix_expressionContext postfix_expression() throws RecognitionEx } } } - setState(504); + setState(508); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,39,_ctx); } @@ -3669,11 +3671,11 @@ private FactorContext factor(int _p) throws RecognitionException { _ctx = _localctx; _prevctx = _localctx; - setState(506); + setState(510); base_factor(); } _ctx.stop = _input.LT(-1); - setState(521); + setState(525); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,41,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { @@ -3681,18 +3683,18 @@ private FactorContext factor(int _p) throws RecognitionException { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { - setState(519); + setState(523); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { case 1: { _localctx = new FactorPointMethodContext(new FactorContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_factor); - setState(508); + setState(512); if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(509); + setState(513); match(POINT); - setState(510); + setState(514); builtin_method(); } break; @@ -3700,11 +3702,11 @@ private FactorContext factor(int _p) throws RecognitionException { { _localctx = new FactorPointIDContext(new FactorContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_factor); - setState(511); + setState(515); if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(512); + setState(516); match(POINT); - setState(513); + setState(517); match(ID); } break; @@ -3712,20 +3714,20 @@ private FactorContext factor(int _p) throws RecognitionException { { _localctx = new FactorArrayContext(new FactorContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_factor); - setState(514); + setState(518); if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(515); + setState(519); match(LBRA); - setState(516); + setState(520); expression(); - setState(517); + setState(521); match(RBRA); } break; } } } - setState(523); + setState(527); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,41,_ctx); } @@ -3819,14 +3821,14 @@ public final Base_factorContext base_factor() throws RecognitionException { Base_factorContext _localctx = new Base_factorContext(_ctx, getState()); enterRule(_localctx, 76, RULE_base_factor); try { - setState(537); + setState(541); _errHandler.sync(this); switch (_input.LA(1)) { case RESULT: _localctx = new ResultFactorContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(524); + setState(528); match(RESULT); } break; @@ -3855,10 +3857,11 @@ public final Base_factorContext base_factor() throws RecognitionException { _localctx = new RefNameFactorContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(525); + setState(529); ref_name(); } break; + case EMPTYMAP: case EMPTYSET: case EMPTYLIST: case EMPTYSTRUCTURE: @@ -3873,7 +3876,7 @@ public final Base_factorContext base_factor() throws RecognitionException { _localctx = new ValueFactorContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(526); + setState(530); value(); } break; @@ -3881,11 +3884,11 @@ public final Base_factorContext base_factor() throws RecognitionException { _localctx = new ParanthesesFactorContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(527); + setState(531); match(LPAR); - setState(528); + setState(532); expression(); - setState(529); + setState(533); match(RPAR); } break; @@ -3893,15 +3896,15 @@ public final Base_factorContext base_factor() throws RecognitionException { _localctx = new AnnoFactorContext(_localctx); enterOuterAlt(_localctx, 5); { - setState(531); + setState(535); match(ANNO); - setState(532); + setState(536); anno(); - setState(533); + setState(537); match(LPAR); - setState(534); + setState(538); expression(); - setState(535); + setState(539); match(RPAR); } break; @@ -3948,7 +3951,7 @@ public final AnnoContext anno() throws RecognitionException { _localctx = new CountAnnoContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(539); + setState(543); match(COUNT); } } @@ -3985,7 +3988,7 @@ public final ValueContext value() throws RecognitionException { ValueContext _localctx = new ValueContext(_ctx, getState()); enterRule(_localctx, 80, RULE_value); try { - setState(543); + setState(547); _errHandler.sync(this); switch (_input.LA(1)) { case INT: @@ -3995,10 +3998,11 @@ public final ValueContext value() throws RecognitionException { case STRING: enterOuterAlt(_localctx, 1); { - setState(541); + setState(545); scalar_value(); } break; + case EMPTYMAP: case EMPTYSET: case EMPTYLIST: case EMPTYSTRUCTURE: @@ -4007,7 +4011,7 @@ public final ValueContext value() throws RecognitionException { case LBRA: enterOuterAlt(_localctx, 2); { - setState(542); + setState(546); data_structure(); } break; @@ -4087,14 +4091,14 @@ public final Scalar_valueContext scalar_value() throws RecognitionException { Scalar_valueContext _localctx = new Scalar_valueContext(_ctx, getState()); enterRule(_localctx, 82, RULE_scalar_value); try { - setState(550); + setState(554); _errHandler.sync(this); switch (_input.LA(1)) { case INT: _localctx = new IntValueContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(545); + setState(549); match(INT); } break; @@ -4102,7 +4106,7 @@ public final Scalar_valueContext scalar_value() throws RecognitionException { _localctx = new DoubleValueContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(546); + setState(550); match(DOUBLE); } break; @@ -4110,7 +4114,7 @@ public final Scalar_valueContext scalar_value() throws RecognitionException { _localctx = new BoolValueContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(547); + setState(551); match(BOOL); } break; @@ -4118,7 +4122,7 @@ public final Scalar_valueContext scalar_value() throws RecognitionException { _localctx = new StringValueContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(548); + setState(552); match(STRING); } break; @@ -4126,7 +4130,7 @@ public final Scalar_valueContext scalar_value() throws RecognitionException { _localctx = new UnknownValueContext(_localctx); enterOuterAlt(_localctx, 5); { - setState(549); + setState(553); match(QUESTION); } break; @@ -4191,14 +4195,14 @@ public final Ref_nameContext ref_name() throws RecognitionException { Ref_nameContext _localctx = new Ref_nameContext(_ctx, getState()); enterRule(_localctx, 84, RULE_ref_name); try { - setState(556); + setState(560); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { case 1: _localctx = new RefFunctionCallContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(552); + setState(556); function_call(); } break; @@ -4206,7 +4210,7 @@ public final Ref_nameContext ref_name() throws RecognitionException { _localctx = new RefIDContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(553); + setState(557); match(ID); } break; @@ -4214,9 +4218,9 @@ public final Ref_nameContext ref_name() throws RecognitionException { _localctx = new SymIDContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(554); + setState(558); match(SYM); - setState(555); + setState(559); match(ID); } break; @@ -4288,19 +4292,30 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + public static class MappingValueContext extends Data_structureContext { + public MappingContext mapping() { + return getRuleContext(MappingContext.class,0); + } + public MappingValueContext(Data_structureContext ctx) { copyFrom(ctx); } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof alkVisitor ) return ((alkVisitor)visitor).visitMappingValue(this); + else return visitor.visitChildren(this); + } + } public final Data_structureContext data_structure() throws RecognitionException { Data_structureContext _localctx = new Data_structureContext(_ctx, getState()); enterRule(_localctx, 86, RULE_data_structure); try { - setState(562); + setState(567); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) { case 1: _localctx = new ArrayValueContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(558); + setState(562); array(); } break; @@ -4308,7 +4323,7 @@ public final Data_structureContext data_structure() throws RecognitionException _localctx = new ListValueContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(559); + setState(563); list(); } break; @@ -4316,7 +4331,7 @@ public final Data_structureContext data_structure() throws RecognitionException _localctx = new SetValueContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(560); + setState(564); set(); } break; @@ -4324,10 +4339,18 @@ public final Data_structureContext data_structure() throws RecognitionException _localctx = new StructureValueContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(561); + setState(565); structure(); } break; + case 5: + _localctx = new MappingValueContext(_localctx); + enterOuterAlt(_localctx, 5); + { + setState(566); + mapping(); + } + break; } } catch (RecognitionException re) { @@ -4378,13 +4401,13 @@ public final IntervalContext interval() throws RecognitionException { _localctx = new IntervalDefinitionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(564); + setState(569); expression(); - setState(565); + setState(570); match(POINT); - setState(566); + setState(571); match(POINT); - setState(567); + setState(572); expression(); } } @@ -4449,22 +4472,22 @@ public final SpecContext spec() throws RecognitionException { SpecContext _localctx = new SpecContext(_ctx, getState()); enterRule(_localctx, 90, RULE_spec); try { - setState(581); + setState(586); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { case 1: _localctx = new FilterSpecDefinitionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(569); + setState(574); match(ID); - setState(570); + setState(575); match(FROM); - setState(571); + setState(576); expression(); - setState(572); + setState(577); match(VBAR); - setState(573); + setState(578); expression(); } break; @@ -4472,15 +4495,15 @@ public final SpecContext spec() throws RecognitionException { _localctx = new SelectSpecDefinitionContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(575); + setState(580); expression(); - setState(576); + setState(581); match(VBAR); - setState(577); + setState(582); match(ID); - setState(578); + setState(583); match(FROM); - setState(579); + setState(584); expression(); } break; @@ -4560,18 +4583,18 @@ public final ArrayContext array() throws RecognitionException { enterRule(_localctx, 92, RULE_array); int _la; try { - setState(603); + setState(608); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { case 1: _localctx = new ArrayWithSpecContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(583); + setState(588); match(LBRA); - setState(584); + setState(589); spec(); - setState(585); + setState(590); match(RBRA); } break; @@ -4579,35 +4602,35 @@ public final ArrayContext array() throws RecognitionException { _localctx = new ArrayWithExpressionsContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(587); + setState(592); match(LBRA); - setState(596); + setState(601); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0)) { { - setState(588); - expression(); setState(593); + expression(); + setState(598); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(589); + setState(594); match(COMMA); - setState(590); + setState(595); expression(); } } - setState(595); + setState(600); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(598); + setState(603); match(RBRA); } break; @@ -4615,11 +4638,11 @@ public final ArrayContext array() throws RecognitionException { _localctx = new ArrayWithIntervalContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(599); + setState(604); match(LBRA); - setState(600); + setState(605); interval(); - setState(601); + setState(606); match(RBRA); } break; @@ -4702,14 +4725,14 @@ public final ListContext list() throws RecognitionException { enterRule(_localctx, 94, RULE_list); int _la; try { - setState(626); + setState(631); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) { case 1: _localctx = new EmptyListContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(605); + setState(610); match(EMPTYLIST); } break; @@ -4717,11 +4740,11 @@ public final ListContext list() throws RecognitionException { _localctx = new ListWithSpecContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(606); + setState(611); match(LOWER); - setState(607); + setState(612); spec(); - setState(608); + setState(613); match(GREATER); } break; @@ -4729,35 +4752,35 @@ public final ListContext list() throws RecognitionException { _localctx = new ListWithExpressionsContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(610); + setState(615); match(LOWER); - setState(619); + setState(624); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0)) { { - setState(611); - expression(); setState(616); + expression(); + setState(621); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(612); + setState(617); match(COMMA); - setState(613); + setState(618); expression(); } } - setState(618); + setState(623); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(621); + setState(626); match(GREATER); } break; @@ -4765,11 +4788,11 @@ public final ListContext list() throws RecognitionException { _localctx = new ListWithIntervalContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(622); + setState(627); match(LOWER); - setState(623); + setState(628); interval(); - setState(624); + setState(629); match(GREATER); } break; @@ -4831,30 +4854,30 @@ public final StructureContext structure() throws RecognitionException { enterRule(_localctx, 96, RULE_structure); int _la; try { - setState(642); + setState(647); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) { case 1: _localctx = new StructureWithComponentsContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(628); + setState(633); match(LCB); - setState(630); + setState(635); _errHandler.sync(this); _la = _input.LA(1); do { { { - setState(629); + setState(634); component(); } } - setState(632); + setState(637); _errHandler.sync(this); _la = _input.LA(1); } while ( _la==ID ); - setState(634); + setState(639); match(RCB); } break; @@ -4862,22 +4885,22 @@ public final StructureContext structure() throws RecognitionException { _localctx = new EmptyStructureContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(640); + setState(645); _errHandler.sync(this); switch (_input.LA(1)) { case EMPTYSTRUCTURE: { - setState(636); + setState(641); match(EMPTYSTRUCTURE); } break; case LCB: { - setState(637); + setState(642); match(LCB); - setState(638); + setState(643); match(ARROW); - setState(639); + setState(644); match(RCB); } break; @@ -4931,11 +4954,11 @@ public final ComponentContext component() throws RecognitionException { _localctx = new ComponentDefinitionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(644); + setState(649); match(ID); - setState(645); + setState(650); match(ARROW); - setState(646); + setState(651); expression(); } } @@ -5022,14 +5045,14 @@ public final SetContext set() throws RecognitionException { enterRule(_localctx, 100, RULE_set); int _la; try { - setState(669); + setState(674); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) { case 1: _localctx = new EmptySetContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(648); + setState(653); match(EMPTYSET); } break; @@ -5037,11 +5060,11 @@ public final SetContext set() throws RecognitionException { _localctx = new SetWithSpecContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(649); + setState(654); match(LCB); - setState(650); + setState(655); spec(); - setState(651); + setState(656); match(RCB); } break; @@ -5049,35 +5072,35 @@ public final SetContext set() throws RecognitionException { _localctx = new SetWithExpressionsContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(653); + setState(658); match(LCB); - setState(662); + setState(667); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0)) { { - setState(654); - expression(); setState(659); + expression(); + setState(664); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(655); + setState(660); match(COMMA); - setState(656); + setState(661); expression(); } } - setState(661); + setState(666); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(664); + setState(669); match(RCB); } break; @@ -5085,11 +5108,124 @@ public final SetContext set() throws RecognitionException { _localctx = new SetWithIntervalContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(665); + setState(670); match(LCB); - setState(666); + setState(671); interval(); - setState(667); + setState(672); + match(RCB); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MappingContext extends ParserRuleContext { + public MappingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mapping; } + + public MappingContext() { } + public void copyFrom(MappingContext ctx) { + super.copyFrom(ctx); + } + } + public static class MappingWithComponentsContext extends MappingContext { + public TerminalNode LCB() { return getToken(alkParser.LCB, 0); } + public TerminalNode RCB() { return getToken(alkParser.RCB, 0); } + public List mapping_component() { + return getRuleContexts(Mapping_componentContext.class); + } + public Mapping_componentContext mapping_component(int i) { + return getRuleContext(Mapping_componentContext.class,i); + } + public MappingWithComponentsContext(MappingContext ctx) { copyFrom(ctx); } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof alkVisitor ) return ((alkVisitor)visitor).visitMappingWithComponents(this); + else return visitor.visitChildren(this); + } + } + public static class EmptyMappingContext extends MappingContext { + public TerminalNode EMPTYMAP() { return getToken(alkParser.EMPTYMAP, 0); } + public TerminalNode LCB() { return getToken(alkParser.LCB, 0); } + public TerminalNode TO() { return getToken(alkParser.TO, 0); } + public TerminalNode RCB() { return getToken(alkParser.RCB, 0); } + public EmptyMappingContext(MappingContext ctx) { copyFrom(ctx); } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof alkVisitor ) return ((alkVisitor)visitor).visitEmptyMapping(this); + else return visitor.visitChildren(this); + } + } + + public final MappingContext mapping() throws RecognitionException { + MappingContext _localctx = new MappingContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_mapping); + int _la; + try { + setState(690); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { + case 1: + _localctx = new EmptyMappingContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(680); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EMPTYMAP: + { + setState(676); + match(EMPTYMAP); + } + break; + case LCB: + { + setState(677); + match(LCB); + setState(678); + match(TO); + setState(679); + match(RCB); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + _localctx = new MappingWithComponentsContext(_localctx); + enterOuterAlt(_localctx, 2); + { + setState(682); + match(LCB); + setState(684); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(683); + mapping_component(); + } + } + setState(686); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( ((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0) ); + setState(688); match(RCB); } break; @@ -5106,6 +5242,59 @@ public final SetContext set() throws RecognitionException { return _localctx; } + public static class Mapping_componentContext extends ParserRuleContext { + public Mapping_componentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mapping_component; } + + public Mapping_componentContext() { } + public void copyFrom(Mapping_componentContext ctx) { + super.copyFrom(ctx); + } + } + public static class MappingComponentDefinitionContext extends Mapping_componentContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode TO() { return getToken(alkParser.TO, 0); } + public MappingComponentDefinitionContext(Mapping_componentContext ctx) { copyFrom(ctx); } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof alkVisitor ) return ((alkVisitor)visitor).visitMappingComponentDefinition(this); + else return visitor.visitChildren(this); + } + } + + public final Mapping_componentContext mapping_component() throws RecognitionException { + Mapping_componentContext _localctx = new Mapping_componentContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_mapping_component); + try { + _localctx = new MappingComponentDefinitionContext(_localctx); + enterOuterAlt(_localctx, 1); + { + setState(692); + expression(); + setState(693); + match(TO); + setState(694); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + public static class Function_callContext extends ParserRuleContext { public Function_callContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -5152,10 +5341,10 @@ public T accept(ParseTreeVisitor visitor) { public final Function_callContext function_call() throws RecognitionException { Function_callContext _localctx = new Function_callContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_function_call); + enterRule(_localctx, 106, RULE_function_call); int _la; try { - setState(685); + setState(710); _errHandler.sync(this); switch (_input.LA(1)) { case ABS: @@ -5181,7 +5370,7 @@ public final Function_callContext function_call() throws RecognitionException { _localctx = new ToBuiltinFunctionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(671); + setState(696); builtin_function(); } break; @@ -5189,37 +5378,37 @@ public final Function_callContext function_call() throws RecognitionException { _localctx = new DefinedFunctionCallContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(672); + setState(697); match(ID); - setState(673); + setState(698); match(LPAR); - setState(682); + setState(707); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0)) { { - setState(674); + setState(699); expression(); - setState(679); + setState(704); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(675); + setState(700); match(COMMA); - setState(676); + setState(701); expression(); } } - setState(681); + setState(706); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(684); + setState(709); match(RPAR); } break; @@ -5275,43 +5464,43 @@ public T accept(ParseTreeVisitor visitor) { public final Builtin_functionContext builtin_function() throws RecognitionException { Builtin_functionContext _localctx = new Builtin_functionContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_builtin_function); + enterRule(_localctx, 108, RULE_builtin_function); int _la; try { _localctx = new BuiltinFunctionContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(687); + setState(712); function_name(); - setState(688); + setState(713); match(LPAR); - setState(697); + setState(722); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0)) { { - setState(689); + setState(714); expression(); - setState(694); + setState(719); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(690); + setState(715); match(COMMA); - setState(691); + setState(716); expression(); } } - setState(696); + setState(721); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(699); + setState(724); match(RPAR); } } @@ -5363,43 +5552,43 @@ public T accept(ParseTreeVisitor visitor) { public final Builtin_methodContext builtin_method() throws RecognitionException { Builtin_methodContext _localctx = new Builtin_methodContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_builtin_method); + enterRule(_localctx, 110, RULE_builtin_method); int _la; try { _localctx = new BuiltinMethodContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(701); + setState(726); method_name(); - setState(702); + setState(727); match(LPAR); - setState(711); + setState(736); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & ((1L << (SINGLETONSET - 75)) | (1L << (UNIFORMNAT - 75)) | (1L << (FLIP - 75)) | (1L << (UNIFORMFLOAT - 75)) | (1L << (UNIFORMPERM - 75)) | (1L << (SYM - 75)) | (1L << (ANNO - 75)) | (1L << (INT - 75)) | (1L << (DOUBLE - 75)) | (1L << (BOOL - 75)) | (1L << (ID - 75)) | (1L << (PLUSPLUS - 75)) | (1L << (MINUSMINUS - 75)) | (1L << (PLUSPLUSMOD - 75)) | (1L << (MINUSMINUSMOD - 75)) | (1L << (LOWER - 75)) | (1L << (MINUS - 75)) | (1L << (PLUS - 75)) | (1L << (MUL - 75)) | (1L << (LPAR - 75)) | (1L << (NOT - 75)) | (1L << (LCB - 75)) | (1L << (LBRA - 75)) | (1L << (QUESTION - 75)) | (1L << (STRING - 75)))) != 0)) { + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (RESULT - 10)) | (1L << (FORALL - 10)) | (1L << (EXISTS - 10)) | (1L << (EMPTYMAP - 10)) | (1L << (EMPTYSET - 10)) | (1L << (EMPTYLIST - 10)) | (1L << (EMPTYSTRUCTURE - 10)) | (1L << (ABS - 10)) | (1L << (ACOS - 10)) | (1L << (ASIN - 10)) | (1L << (ATAN - 10)) | (1L << (COS - 10)) | (1L << (LOG - 10)) | (1L << (PI - 10)) | (1L << (POW - 10)) | (1L << (SIN - 10)) | (1L << (SQRT - 10)) | (1L << (TAN - 10)) | (1L << (LEN - 10)) | (1L << (FLOAT - 10)) | (1L << (INTEGER - 10)) | (1L << (PRINT - 10)))) != 0) || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (SINGLETONSET - 76)) | (1L << (UNIFORMNAT - 76)) | (1L << (FLIP - 76)) | (1L << (UNIFORMFLOAT - 76)) | (1L << (UNIFORMPERM - 76)) | (1L << (SYM - 76)) | (1L << (ANNO - 76)) | (1L << (INT - 76)) | (1L << (DOUBLE - 76)) | (1L << (BOOL - 76)) | (1L << (ID - 76)) | (1L << (PLUSPLUS - 76)) | (1L << (MINUSMINUS - 76)) | (1L << (PLUSPLUSMOD - 76)) | (1L << (MINUSMINUSMOD - 76)) | (1L << (LOWER - 76)) | (1L << (MINUS - 76)) | (1L << (PLUS - 76)) | (1L << (MUL - 76)) | (1L << (LPAR - 76)) | (1L << (NOT - 76)) | (1L << (LCB - 76)) | (1L << (LBRA - 76)) | (1L << (QUESTION - 76)) | (1L << (STRING - 76)))) != 0)) { { - setState(703); + setState(728); expression(); - setState(708); + setState(733); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(704); + setState(729); match(COMMA); - setState(705); + setState(730); expression(); } } - setState(710); + setState(735); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(713); + setState(738); match(RPAR); } } @@ -5483,16 +5672,16 @@ public T accept(ParseTreeVisitor visitor) { public final DataTypeContext dataType() throws RecognitionException { DataTypeContext _localctx = new DataTypeContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_dataType); + enterRule(_localctx, 112, RULE_dataType); try { - setState(728); + setState(753); _errHandler.sync(this); switch (_input.LA(1)) { case INTEGER: _localctx = new IntTypeContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(715); + setState(740); match(INTEGER); } break; @@ -5500,7 +5689,7 @@ public final DataTypeContext dataType() throws RecognitionException { _localctx = new BoolTypeContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(716); + setState(741); match(BOOLEAN); } break; @@ -5508,7 +5697,7 @@ public final DataTypeContext dataType() throws RecognitionException { _localctx = new FloatTypeContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(717); + setState(742); match(FLOAT); } break; @@ -5516,13 +5705,13 @@ public final DataTypeContext dataType() throws RecognitionException { _localctx = new ArrayTypeContext(_localctx); enterOuterAlt(_localctx, 4); { - setState(718); + setState(743); match(ARRAY); - setState(719); + setState(744); match(LOWER); - setState(720); + setState(745); dataType(); - setState(721); + setState(746); match(GREATER); } break; @@ -5530,13 +5719,13 @@ public final DataTypeContext dataType() throws RecognitionException { _localctx = new SetTypeContext(_localctx); enterOuterAlt(_localctx, 5); { - setState(723); + setState(748); match(SET); - setState(724); + setState(749); match(LOWER); - setState(725); + setState(750); dataType(); - setState(726); + setState(751); match(GREATER); } break; @@ -5589,14 +5778,14 @@ public T accept(ParseTreeVisitor visitor) { public final Function_nameContext function_name() throws RecognitionException { Function_nameContext _localctx = new Function_nameContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_function_name); + enterRule(_localctx, 114, RULE_function_name); int _la; try { enterOuterAlt(_localctx, 1); { - setState(730); + setState(755); _la = _input.LA(1); - if ( !(((((_la - 43)) & ~0x3f) == 0 && ((1L << (_la - 43)) & ((1L << (ABS - 43)) | (1L << (ACOS - 43)) | (1L << (ASIN - 43)) | (1L << (ATAN - 43)) | (1L << (COS - 43)) | (1L << (LOG - 43)) | (1L << (PI - 43)) | (1L << (POW - 43)) | (1L << (SIN - 43)) | (1L << (SQRT - 43)) | (1L << (TAN - 43)) | (1L << (LEN - 43)) | (1L << (FLOAT - 43)) | (1L << (INTEGER - 43)) | (1L << (PRINT - 43)) | (1L << (SINGLETONSET - 43)) | (1L << (UNIFORMNAT - 43)) | (1L << (FLIP - 43)) | (1L << (UNIFORMFLOAT - 43)) | (1L << (UNIFORMPERM - 43)))) != 0)) ) { + if ( !(((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (ABS - 44)) | (1L << (ACOS - 44)) | (1L << (ASIN - 44)) | (1L << (ATAN - 44)) | (1L << (COS - 44)) | (1L << (LOG - 44)) | (1L << (PI - 44)) | (1L << (POW - 44)) | (1L << (SIN - 44)) | (1L << (SQRT - 44)) | (1L << (TAN - 44)) | (1L << (LEN - 44)) | (1L << (FLOAT - 44)) | (1L << (INTEGER - 44)) | (1L << (PRINT - 44)) | (1L << (SINGLETONSET - 44)) | (1L << (UNIFORMNAT - 44)) | (1L << (FLIP - 44)) | (1L << (UNIFORMFLOAT - 44)) | (1L << (UNIFORMPERM - 44)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -5648,14 +5837,14 @@ public T accept(ParseTreeVisitor visitor) { public final Method_nameContext method_name() throws RecognitionException { Method_nameContext _localctx = new Method_nameContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_method_name); + enterRule(_localctx, 116, RULE_method_name); int _la; try { enterOuterAlt(_localctx, 1); { - setState(732); + setState(757); _la = _input.LA(1); - if ( !(((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (AT - 57)) | (1L << (DELETE - 57)) | (1L << (END - 57)) | (1L << (FIRST - 57)) | (1L << (INSERT - 57)) | (1L << (POPBACK - 57)) | (1L << (POPFRONT - 57)) | (1L << (PUSHBACK - 57)) | (1L << (PUSHFRONT - 57)) | (1L << (REMOVE - 57)) | (1L << (REMOVEALLEQTO - 57)) | (1L << (REMOVEAT - 57)) | (1L << (SIZE - 57)) | (1L << (SPLIT - 57)) | (1L << (TOPBACK - 57)) | (1L << (TOPFRONT - 57)) | (1L << (UPDATE - 57)))) != 0)) ) { + if ( !(((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & ((1L << (AT - 58)) | (1L << (DELETE - 58)) | (1L << (END - 58)) | (1L << (FIRST - 58)) | (1L << (INSERT - 58)) | (1L << (POPBACK - 58)) | (1L << (POPFRONT - 58)) | (1L << (PUSHBACK - 58)) | (1L << (PUSHFRONT - 58)) | (1L << (REMOVE - 58)) | (1L << (REMOVEALLEQTO - 58)) | (1L << (REMOVEAT - 58)) | (1L << (SIZE - 58)) | (1L << (SPLIT - 58)) | (1L << (TOPBACK - 58)) | (1L << (TOPFRONT - 58)) | (1L << (UPDATE - 58)))) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -5713,31 +5902,31 @@ public T accept(ParseTreeVisitor visitor) { public final ConfigurationContext configuration() throws RecognitionException { ConfigurationContext _localctx = new ConfigurationContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_configuration); + enterRule(_localctx, 118, RULE_configuration); int _la; try { _localctx = new ConfigContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(739); + setState(764); _errHandler.sync(this); _la = _input.LA(1); while (_la==ID) { { { - setState(734); + setState(759); match(ID); - setState(735); + setState(760); match(TO); - setState(736); + setState(761); expression(); } } - setState(741); + setState(766); _errHandler.sync(this); _la = _input.LA(1); } - setState(742); + setState(767); match(EOF); } } @@ -5772,289 +5961,299 @@ private boolean factor_sempred(FactorContext _localctx, int predIndex) { } public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0089\u02eb\4\2\t"+ + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u008a\u0304\4\2\t"+ "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\3\2\5\2x\n\2"+ - "\3\2\3\2\3\3\6\3}\n\3\r\3\16\3~\3\4\3\4\3\4\5\4\u0084\n\4\3\4\3\4\3\4"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\3\2\5\2|\n\2\3\2\3\2\3\3\6\3\u0081\n\3\r\3\16\3\u0082\3\4\3\4\3\4\5\4"+ + "\u0088\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4"+ "\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+ - "\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4"+ - "\3\4\5\4\u00ad\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\3\7\3\7\7\7\u00b9\n"+ - "\7\f\7\16\7\u00bc\13\7\3\b\3\b\3\b\3\b\7\b\u00c2\n\b\f\b\16\b\u00c5\13"+ - "\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3"+ - "\13\3\f\3\f\5\f\u00d9\n\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u00e3\n"+ - "\r\3\r\3\r\3\r\3\r\3\r\5\r\u00ea\n\r\3\16\3\16\3\16\3\16\3\16\3\16\7\16"+ - "\u00f2\n\16\f\16\16\16\u00f5\13\16\3\16\3\16\3\16\3\16\7\16\u00fb\n\16"+ - "\f\16\16\16\u00fe\13\16\5\16\u0100\n\16\3\16\3\16\3\17\3\17\3\17\3\17"+ - "\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u0112\n\20\3\21"+ - "\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22"+ - "\3\22\3\23\3\23\3\23\3\23\3\23\7\23\u0129\n\23\f\23\16\23\u012c\13\23"+ - "\5\23\u012e\n\23\3\23\3\23\3\23\5\23\u0133\n\23\3\23\3\23\3\23\3\23\7"+ - "\23\u0139\n\23\f\23\16\23\u013c\13\23\5\23\u013e\n\23\3\23\3\23\7\23\u0142"+ - "\n\23\f\23\16\23\u0145\13\23\3\23\3\23\7\23\u0149\n\23\f\23\16\23\u014c"+ - "\13\23\3\23\3\23\3\24\3\24\3\25\3\25\3\26\5\26\u0155\n\26\3\26\3\26\3"+ - "\26\5\26\u015a\n\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27"+ - "\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u016c\n\27\f\27\16\27\u016f\13\27"+ - "\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u017c\n\27"+ - "\f\27\16\27\u017f\13\27\3\27\3\27\3\27\3\27\5\27\u0185\n\27\3\30\3\30"+ - "\3\30\3\30\3\30\5\30\u018c\n\30\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0194"+ - "\n\31\3\32\3\32\3\32\7\32\u0199\n\32\f\32\16\32\u019c\13\32\3\33\3\33"+ - "\3\33\7\33\u01a1\n\33\f\33\16\33\u01a4\13\33\3\34\3\34\3\34\7\34\u01a9"+ - "\n\34\f\34\16\34\u01ac\13\34\3\35\3\35\3\35\7\35\u01b1\n\35\f\35\16\35"+ - "\u01b4\13\35\3\36\3\36\3\36\7\36\u01b9\n\36\f\36\16\36\u01bc\13\36\3\37"+ - "\3\37\3\37\7\37\u01c1\n\37\f\37\16\37\u01c4\13\37\3 \3 \3 \7 \u01c9\n"+ - " \f \16 \u01cc\13 \3!\3!\3!\7!\u01d1\n!\f!\16!\u01d4\13!\3\"\3\"\3\"\7"+ - "\"\u01d9\n\"\f\"\16\"\u01dc\13\"\3#\3#\3#\7#\u01e1\n#\f#\16#\u01e4\13"+ - "#\3$\3$\3$\7$\u01e9\n$\f$\16$\u01ec\13$\3%\3%\3%\3%\3%\5%\u01f3\n%\3&"+ - "\3&\7&\u01f7\n&\f&\16&\u01fa\13&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3"+ - "\'\3\'\3\'\3\'\3\'\7\'\u020a\n\'\f\'\16\'\u020d\13\'\3(\3(\3(\3(\3(\3"+ - "(\3(\3(\3(\3(\3(\3(\3(\5(\u021c\n(\3)\3)\3*\3*\5*\u0222\n*\3+\3+\3+\3"+ - "+\3+\5+\u0229\n+\3,\3,\3,\3,\5,\u022f\n,\3-\3-\3-\3-\5-\u0235\n-\3.\3"+ - ".\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u0248\n/\3\60\3\60\3"+ - "\60\3\60\3\60\3\60\3\60\3\60\7\60\u0252\n\60\f\60\16\60\u0255\13\60\5"+ - "\60\u0257\n\60\3\60\3\60\3\60\3\60\3\60\5\60\u025e\n\60\3\61\3\61\3\61"+ - "\3\61\3\61\3\61\3\61\3\61\3\61\7\61\u0269\n\61\f\61\16\61\u026c\13\61"+ - "\5\61\u026e\n\61\3\61\3\61\3\61\3\61\3\61\5\61\u0275\n\61\3\62\3\62\6"+ - "\62\u0279\n\62\r\62\16\62\u027a\3\62\3\62\3\62\3\62\3\62\3\62\5\62\u0283"+ - "\n\62\5\62\u0285\n\62\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64"+ - "\3\64\3\64\3\64\7\64\u0294\n\64\f\64\16\64\u0297\13\64\5\64\u0299\n\64"+ - "\3\64\3\64\3\64\3\64\3\64\5\64\u02a0\n\64\3\65\3\65\3\65\3\65\3\65\3\65"+ - "\7\65\u02a8\n\65\f\65\16\65\u02ab\13\65\5\65\u02ad\n\65\3\65\5\65\u02b0"+ - "\n\65\3\66\3\66\3\66\3\66\3\66\7\66\u02b7\n\66\f\66\16\66\u02ba\13\66"+ - "\5\66\u02bc\n\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\7\67\u02c5\n\67\f"+ - "\67\16\67\u02c8\13\67\5\67\u02ca\n\67\3\67\3\67\38\38\38\38\38\38\38\3"+ - "8\38\38\38\38\38\58\u02db\n8\39\39\3:\3:\3;\3;\3;\7;\u02e4\n;\f;\16;\u02e7"+ - "\13;\3;\3;\3;\2\3L<\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+ - "\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprt\2\17\3\2)*\3\2op\3\2kn\3\2]"+ - "_\4\2,,\u0080\u0080\3\2yz\4\2ghrs\3\2tv\4\2deij\4\2rt}}\3\2de\b\2-8AA"+ - "CCEEMMSV\b\2;;==?@BBFLNR\2\u031d\2w\3\2\2\2\4|\3\2\2\2\6\u00ac\3\2\2\2"+ - "\b\u00ae\3\2\2\2\n\u00b1\3\2\2\2\f\u00b4\3\2\2\2\16\u00bd\3\2\2\2\20\u00c6"+ - "\3\2\2\2\22\u00cb\3\2\2\2\24\u00cf\3\2\2\2\26\u00d6\3\2\2\2\30\u00e9\3"+ - "\2\2\2\32\u00eb\3\2\2\2\34\u0103\3\2\2\2\36\u010a\3\2\2\2 \u0113\3\2\2"+ - "\2\"\u011d\3\2\2\2$\u0123\3\2\2\2&\u014f\3\2\2\2(\u0151\3\2\2\2*\u0154"+ - "\3\2\2\2,\u0184\3\2\2\2.\u018b\3\2\2\2\60\u018d\3\2\2\2\62\u0195\3\2\2"+ - "\2\64\u019d\3\2\2\2\66\u01a5\3\2\2\28\u01ad\3\2\2\2:\u01b5\3\2\2\2<\u01bd"+ - "\3\2\2\2>\u01c5\3\2\2\2@\u01cd\3\2\2\2B\u01d5\3\2\2\2D\u01dd\3\2\2\2F"+ - "\u01e5\3\2\2\2H\u01f2\3\2\2\2J\u01f4\3\2\2\2L\u01fb\3\2\2\2N\u021b\3\2"+ - "\2\2P\u021d\3\2\2\2R\u0221\3\2\2\2T\u0228\3\2\2\2V\u022e\3\2\2\2X\u0234"+ - "\3\2\2\2Z\u0236\3\2\2\2\\\u0247\3\2\2\2^\u025d\3\2\2\2`\u0274\3\2\2\2"+ - "b\u0284\3\2\2\2d\u0286\3\2\2\2f\u029f\3\2\2\2h\u02af\3\2\2\2j\u02b1\3"+ - "\2\2\2l\u02bf\3\2\2\2n\u02da\3\2\2\2p\u02dc\3\2\2\2r\u02de\3\2\2\2t\u02e5"+ - "\3\2\2\2vx\5\4\3\2wv\3\2\2\2wx\3\2\2\2xy\3\2\2\2yz\7\2\2\3z\3\3\2\2\2"+ - "{}\5\6\4\2|{\3\2\2\2}~\3\2\2\2~|\3\2\2\2~\177\3\2\2\2\177\5\3\2\2\2\u0080"+ - "\u00ad\5$\23\2\u0081\u0083\7 \2\2\u0082\u0084\5,\27\2\u0083\u0082\3\2"+ - "\2\2\u0083\u0084\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u00ad\7~\2\2\u0086"+ - "\u0087\5\30\r\2\u0087\u0088\7~\2\2\u0088\u00ad\3\2\2\2\u0089\u008a\7!"+ - "\2\2\u008a\u00ad\7~\2\2\u008b\u008c\7#\2\2\u008c\u00ad\7~\2\2\u008d\u008e"+ - "\7$\2\2\u008e\u00ad\7~\2\2\u008f\u0090\7%\2\2\u0090\u00ad\7~\2\2\u0091"+ - "\u00ad\5\26\f\2\u0092\u00ad\5\22\n\2\u0093\u0094\5\24\13\2\u0094\u0095"+ - "\7~\2\2\u0095\u00ad\3\2\2\2\u0096\u00ad\5\32\16\2\u0097\u0098\5\34\17"+ - "\2\u0098\u0099\7~\2\2\u0099\u00ad\3\2\2\2\u009a\u00ad\5\36\20\2\u009b"+ - "\u00ad\5 \21\2\u009c\u00ad\5\"\22\2\u009d\u009e\5,\27\2\u009e\u009f\7"+ - "~\2\2\u009f\u00ad\3\2\2\2\u00a0\u00a1\5\16\b\2\u00a1\u00a2\7~\2\2\u00a2"+ - "\u00ad\3\2\2\2\u00a3\u00a4\5\f\7\2\u00a4\u00a5\7~\2\2\u00a5\u00ad\3\2"+ - "\2\2\u00a6\u00a7\5\b\5\2\u00a7\u00a8\7~\2\2\u00a8\u00ad\3\2\2\2\u00a9"+ - "\u00aa\5\n\6\2\u00aa\u00ab\7~\2\2\u00ab\u00ad\3\2\2\2\u00ac\u0080\3\2"+ - "\2\2\u00ac\u0081\3\2\2\2\u00ac\u0086\3\2\2\2\u00ac\u0089\3\2\2\2\u00ac"+ - "\u008b\3\2\2\2\u00ac\u008d\3\2\2\2\u00ac\u008f\3\2\2\2\u00ac\u0091\3\2"+ - "\2\2\u00ac\u0092\3\2\2\2\u00ac\u0093\3\2\2\2\u00ac\u0096\3\2\2\2\u00ac"+ - "\u0097\3\2\2\2\u00ac\u009a\3\2\2\2\u00ac\u009b\3\2\2\2\u00ac\u009c\3\2"+ - "\2\2\u00ac\u009d\3\2\2\2\u00ac\u00a0\3\2\2\2\u00ac\u00a3\3\2\2\2\u00ac"+ - "\u00a6\3\2\2\2\u00ac\u00a9\3\2\2\2\u00ad\7\3\2\2\2\u00ae\u00af\7\7\2\2"+ - "\u00af\u00b0\5,\27\2\u00b0\t\3\2\2\2\u00b1\u00b2\7\6\2\2\u00b2\u00b3\5"+ - ",\27\2\u00b3\13\3\2\2\2\u00b4\u00b5\7\34\2\2\u00b5\u00ba\7c\2\2\u00b6"+ - "\u00b7\7\u0083\2\2\u00b7\u00b9\7c\2\2\u00b8\u00b6\3\2\2\2\u00b9\u00bc"+ - "\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb\r\3\2\2\2\u00bc"+ - "\u00ba\3\2\2\2\u00bd\u00be\7\b\2\2\u00be\u00c3\5\20\t\2\u00bf\u00c0\7"+ - "\u0083\2\2\u00c0\u00c2\5\20\t\2\u00c1\u00bf\3\2\2\2\u00c2\u00c5\3\2\2"+ - "\2\u00c3\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\17\3\2\2\2\u00c5\u00c3"+ - "\3\2\2\2\u00c6\u00c7\7X\2\2\u00c7\u00c8\7c\2\2\u00c8\u00c9\7\177\2\2\u00c9"+ - "\u00ca\5n8\2\u00ca\21\3\2\2\2\u00cb\u00cc\7Z\2\2\u00cc\u00cd\7+\2\2\u00cd"+ - "\u00ce\7\u0089\2\2\u00ce\23\3\2\2\2\u00cf\u00d0\7\37\2\2\u00d0\u00d1\5"+ - "\6\4\2\u00d1\u00d2\7\"\2\2\u00d2\u00d3\7w\2\2\u00d3\u00d4\5,\27\2\u00d4"+ - "\u00d5\7x\2\2\u00d5\25\3\2\2\2\u00d6\u00d8\7\u0081\2\2\u00d7\u00d9\5\4"+ - "\3\2\u00d8\u00d7\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00da\3\2\2\2\u00da"+ - "\u00db\7\u0082\2\2\u00db\27\3\2\2\2\u00dc\u00dd\7\35\2\2\u00dd\u00de\5"+ - ",\27\2\u00de\u00df\7\32\2\2\u00df\u00e2\5,\27\2\u00e0\u00e1\7W\2\2\u00e1"+ - "\u00e3\5,\27\2\u00e2\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00ea\3\2"+ - "\2\2\u00e4\u00e5\7\36\2\2\u00e5\u00e6\5,\27\2\u00e6\u00e7\7\32\2\2\u00e7"+ - "\u00e8\5,\27\2\u00e8\u00ea\3\2\2\2\u00e9\u00dc\3\2\2\2\u00e9\u00e4\3\2"+ - "\2\2\u00ea\31\3\2\2\2\u00eb\u00ec\7\25\2\2\u00ec\u00ed\7w\2\2\u00ed\u00ee"+ - "\5,\27\2\u00ee\u00f3\7x\2\2\u00ef\u00f0\7\t\2\2\u00f0\u00f2\5,\27\2\u00f1"+ - "\u00ef\3\2\2\2\u00f2\u00f5\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f3\u00f4\3\2"+ - "\2\2\u00f4\u00ff\3\2\2\2\u00f5\u00f3\3\2\2\2\u00f6\u00f7\t\2\2\2\u00f7"+ - "\u00fc\7c\2\2\u00f8\u00f9\7\u0083\2\2\u00f9\u00fb\7c\2\2\u00fa\u00f8\3"+ - "\2\2\2\u00fb\u00fe\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd"+ - "\u0100\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff\u00f6\3\2\2\2\u00ff\u0100\3\2"+ - "\2\2\u0100\u0101\3\2\2\2\u0101\u0102\5\6\4\2\u0102\33\3\2\2\2\u0103\u0104"+ - "\7\26\2\2\u0104\u0105\5\6\4\2\u0105\u0106\7\25\2\2\u0106\u0107\7w\2\2"+ - "\u0107\u0108\5,\27\2\u0108\u0109\7x\2\2\u0109\35\3\2\2\2\u010a\u010b\7"+ - "\23\2\2\u010b\u010c\7w\2\2\u010c\u010d\5,\27\2\u010d\u010e\7x\2\2\u010e"+ - "\u0111\5\6\4\2\u010f\u0110\7\24\2\2\u0110\u0112\5\6\4\2\u0111\u010f\3"+ - "\2\2\2\u0111\u0112\3\2\2\2\u0112\37\3\2\2\2\u0113\u0114\7\27\2\2\u0114"+ - "\u0115\7w\2\2\u0115\u0116\5,\27\2\u0116\u0117\7~\2\2\u0117\u0118\5,\27"+ - "\2\u0118\u0119\7~\2\2\u0119\u011a\5,\27\2\u011a\u011b\7x\2\2\u011b\u011c"+ - "\5\6\4\2\u011c!\3\2\2\2\u011d\u011e\7\30\2\2\u011e\u011f\7c\2\2\u011f"+ - "\u0120\7\32\2\2\u0120\u0121\5,\27\2\u0121\u0122\5\6\4\2\u0122#\3\2\2\2"+ - "\u0123\u0124\7c\2\2\u0124\u012d\7w\2\2\u0125\u012a\5*\26\2\u0126\u0127"+ - "\7\u0083\2\2\u0127\u0129\5*\26\2\u0128\u0126\3\2\2\2\u0129\u012c\3\2\2"+ - "\2\u012a\u0128\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012e\3\2\2\2\u012c\u012a"+ - "\3\2\2\2\u012d\u0125\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u012f\3\2\2\2\u012f"+ - "\u0132\7x\2\2\u0130\u0131\7\177\2\2\u0131\u0133\5n8\2\u0132\u0130\3\2"+ - "\2\2\u0132\u0133\3\2\2\2\u0133\u013d\3\2\2\2\u0134\u0135\t\2\2\2\u0135"+ - "\u013a\7c\2\2\u0136\u0137\7\u0083\2\2\u0137\u0139\7c\2\2\u0138\u0136\3"+ - "\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b"+ - "\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013d\u0134\3\2\2\2\u013d\u013e\3\2"+ - "\2\2\u013e\u0143\3\2\2\2\u013f\u0140\7\n\2\2\u0140\u0142\5&\24\2\u0141"+ - "\u013f\3\2\2\2\u0142\u0145\3\2\2\2\u0143\u0141\3\2\2\2\u0143\u0144\3\2"+ - "\2\2\u0144\u014a\3\2\2\2\u0145\u0143\3\2\2\2\u0146\u0147\7\13\2\2\u0147"+ - "\u0149\5(\25\2\u0148\u0146\3\2\2\2\u0149\u014c\3\2\2\2\u014a\u0148\3\2"+ - "\2\2\u014a\u014b\3\2\2\2\u014b\u014d\3\2\2\2\u014c\u014a\3\2\2\2\u014d"+ - "\u014e\5\26\f\2\u014e%\3\2\2\2\u014f\u0150\5,\27\2\u0150\'\3\2\2\2\u0151"+ - "\u0152\5,\27\2\u0152)\3\2\2\2\u0153\u0155\7\33\2\2\u0154\u0153\3\2\2\2"+ - "\u0154\u0155\3\2\2\2\u0155\u0156\3\2\2\2\u0156\u0159\7c\2\2\u0157\u0158"+ - "\7\177\2\2\u0158\u015a\5n8\2\u0159\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a"+ - "+\3\2\2\2\u015b\u015c\5.\30\2\u015c\u015d\7\r\2\2\u015d\u015e\5,\27\2"+ - "\u015e\u0185\3\2\2\2\u015f\u0160\5.\30\2\u0160\u0161\7\16\2\2\u0161\u0162"+ - "\5,\27\2\u0162\u0185\3\2\2\2\u0163\u0164\7\17\2\2\u0164\u0165\7c\2\2\u0165"+ - "\u0166\7\177\2\2\u0166\u016d\5n8\2\u0167\u0168\7\u0083\2\2\u0168\u0169"+ - "\7c\2\2\u0169\u016a\7\177\2\2\u016a\u016c\5n8\2\u016b\u0167\3\2\2\2\u016c"+ - "\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u0170\3\2"+ - "\2\2\u016f\u016d\3\2\2\2\u0170\u0171\7\21\2\2\u0171\u0172\5,\27\2\u0172"+ - "\u0185\3\2\2\2\u0173\u0174\7\20\2\2\u0174\u0175\7c\2\2\u0175\u0176\7\177"+ - "\2\2\u0176\u017d\5n8\2\u0177\u0178\7\u0083\2\2\u0178\u0179\7c\2\2\u0179"+ - "\u017a\7\177\2\2\u017a\u017c\5n8\2\u017b\u0177\3\2\2\2\u017c\u017f\3\2"+ - "\2\2\u017d\u017b\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u0180\3\2\2\2\u017f"+ - "\u017d\3\2\2\2\u0180\u0181\7\21\2\2\u0181\u0182\5,\27\2\u0182\u0185\3"+ - "\2\2\2\u0183\u0185\5.\30\2\u0184\u015b\3\2\2\2\u0184\u015f\3\2\2\2\u0184"+ - "\u0163\3\2\2\2\u0184\u0173\3\2\2\2\u0184\u0183\3\2\2\2\u0185-\3\2\2\2"+ - "\u0186\u0187\5L\'\2\u0187\u0188\7q\2\2\u0188\u0189\5,\27\2\u0189\u018c"+ - "\3\2\2\2\u018a\u018c\5\60\31\2\u018b\u0186\3\2\2\2\u018b\u018a\3\2\2\2"+ - "\u018c/\3\2\2\2\u018d\u0193\5\62\32\2\u018e\u018f\7\u0088\2\2\u018f\u0190"+ - "\5,\27\2\u0190\u0191\7\177\2\2\u0191\u0192\5,\27\2\u0192\u0194\3\2\2\2"+ - "\u0193\u018e\3\2\2\2\u0193\u0194\3\2\2\2\u0194\61\3\2\2\2\u0195\u019a"+ - "\5\64\33\2\u0196\u0197\7{\2\2\u0197\u0199\5\64\33\2\u0198\u0196\3\2\2"+ - "\2\u0199\u019c\3\2\2\2\u019a\u0198\3\2\2\2\u019a\u019b\3\2\2\2\u019b\63"+ - "\3\2\2\2\u019c\u019a\3\2\2\2\u019d\u01a2\5\66\34\2\u019e\u019f\7|\2\2"+ - "\u019f\u01a1\5\66\34\2\u01a0\u019e\3\2\2\2\u01a1\u01a4\3\2\2\2\u01a2\u01a0"+ - "\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3\65\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a5"+ - "\u01aa\58\35\2\u01a6\u01a7\7\31\2\2\u01a7\u01a9\58\35\2\u01a8\u01a6\3"+ - "\2\2\2\u01a9\u01ac\3\2\2\2\u01aa\u01a8\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab"+ - "\67\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ad\u01b2\5:\36\2\u01ae\u01af\t\3\2"+ - "\2\u01af\u01b1\5:\36\2\u01b0\u01ae\3\2\2\2\u01b1\u01b4\3\2\2\2\u01b2\u01b0"+ - "\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b39\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b5"+ - "\u01ba\5<\37\2\u01b6\u01b7\t\4\2\2\u01b7\u01b9\5<\37\2\u01b8\u01b6\3\2"+ - "\2\2\u01b9\u01bc\3\2\2\2\u01ba\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb"+ - ";\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bd\u01c2\5> \2\u01be\u01bf\t\5\2\2\u01bf"+ - "\u01c1\5> \2\u01c0\u01be\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c0\3\2\2"+ - "\2\u01c2\u01c3\3\2\2\2\u01c3=\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c5\u01ca"+ - "\5@!\2\u01c6\u01c7\t\6\2\2\u01c7\u01c9\5@!\2\u01c8\u01c6\3\2\2\2\u01c9"+ - "\u01cc\3\2\2\2\u01ca\u01c8\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb?\3\2\2\2"+ - "\u01cc\u01ca\3\2\2\2\u01cd\u01d2\5B\"\2\u01ce\u01cf\7f\2\2\u01cf\u01d1"+ - "\5B\"\2\u01d0\u01ce\3\2\2\2\u01d1\u01d4\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d2"+ - "\u01d3\3\2\2\2\u01d3A\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d5\u01da\5D#\2\u01d6"+ - "\u01d7\t\7\2\2\u01d7\u01d9\5D#\2\u01d8\u01d6\3\2\2\2\u01d9\u01dc\3\2\2"+ - "\2\u01da\u01d8\3\2\2\2\u01da\u01db\3\2\2\2\u01dbC\3\2\2\2\u01dc\u01da"+ - "\3\2\2\2\u01dd\u01e2\5F$\2\u01de\u01df\t\b\2\2\u01df\u01e1\5F$\2\u01e0"+ - "\u01de\3\2\2\2\u01e1\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3\3\2"+ - "\2\2\u01e3E\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e5\u01ea\5H%\2\u01e6\u01e7"+ - "\t\t\2\2\u01e7\u01e9\5H%\2\u01e8\u01e6\3\2\2\2\u01e9\u01ec\3\2\2\2\u01ea"+ - "\u01e8\3\2\2\2\u01ea\u01eb\3\2\2\2\u01ebG\3\2\2\2\u01ec\u01ea\3\2\2\2"+ - "\u01ed\u01ee\t\n\2\2\u01ee\u01f3\5H%\2\u01ef\u01f0\t\13\2\2\u01f0\u01f3"+ - "\5H%\2\u01f1\u01f3\5J&\2\u01f2\u01ed\3\2\2\2\u01f2\u01ef\3\2\2\2\u01f2"+ - "\u01f1\3\2\2\2\u01f3I\3\2\2\2\u01f4\u01f8\5L\'\2\u01f5\u01f7\t\f\2\2\u01f6"+ - "\u01f5\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8\u01f6\3\2\2\2\u01f8\u01f9\3\2"+ - "\2\2\u01f9K\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fb\u01fc\b\'\1\2\u01fc\u01fd"+ - "\5N(\2\u01fd\u020b\3\2\2\2\u01fe\u01ff\f\6\2\2\u01ff\u0200\7\u0084\2\2"+ - "\u0200\u020a\5l\67\2\u0201\u0202\f\5\2\2\u0202\u0203\7\u0084\2\2\u0203"+ - "\u020a\7c\2\2\u0204\u0205\f\4\2\2\u0205\u0206\7\u0085\2\2\u0206\u0207"+ - "\5,\27\2\u0207\u0208\7\u0086\2\2\u0208\u020a\3\2\2\2\u0209\u01fe\3\2\2"+ - "\2\u0209\u0201\3\2\2\2\u0209\u0204\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209"+ - "\3\2\2\2\u020b\u020c\3\2\2\2\u020cM\3\2\2\2\u020d\u020b\3\2\2\2\u020e"+ - "\u021c\7\f\2\2\u020f\u021c\5V,\2\u0210\u021c\5R*\2\u0211\u0212\7w\2\2"+ - "\u0212\u0213\5,\27\2\u0213\u0214\7x\2\2\u0214\u021c\3\2\2\2\u0215\u0216"+ - "\7[\2\2\u0216\u0217\5P)\2\u0217\u0218\7w\2\2\u0218\u0219\5,\27\2\u0219"+ - "\u021a\7x\2\2\u021a\u021c\3\2\2\2\u021b\u020e\3\2\2\2\u021b\u020f\3\2"+ - "\2\2\u021b\u0210\3\2\2\2\u021b\u0211\3\2\2\2\u021b\u0215\3\2\2\2\u021c"+ - "O\3\2\2\2\u021d\u021e\7\\\2\2\u021eQ\3\2\2\2\u021f\u0222\5T+\2\u0220\u0222"+ - "\5X-\2\u0221\u021f\3\2\2\2\u0221\u0220\3\2\2\2\u0222S\3\2\2\2\u0223\u0229"+ - "\7`\2\2\u0224\u0229\7a\2\2\u0225\u0229\7b\2\2\u0226\u0229\7\u0089\2\2"+ - "\u0227\u0229\7\u0088\2\2\u0228\u0223\3\2\2\2\u0228\u0224\3\2\2\2\u0228"+ - "\u0225\3\2\2\2\u0228\u0226\3\2\2\2\u0228\u0227\3\2\2\2\u0229U\3\2\2\2"+ - "\u022a\u022f\5h\65\2\u022b\u022f\7c\2\2\u022c\u022d\7X\2\2\u022d\u022f"+ - "\7c\2\2\u022e\u022a\3\2\2\2\u022e\u022b\3\2\2\2\u022e\u022c\3\2\2\2\u022f"+ - "W\3\2\2\2\u0230\u0235\5^\60\2\u0231\u0235\5`\61\2\u0232\u0235\5f\64\2"+ - "\u0233\u0235\5b\62\2\u0234\u0230\3\2\2\2\u0234\u0231\3\2\2\2\u0234\u0232"+ - "\3\2\2\2\u0234\u0233\3\2\2\2\u0235Y\3\2\2\2\u0236\u0237\5,\27\2\u0237"+ - "\u0238\7\u0084\2\2\u0238\u0239\7\u0084\2\2\u0239\u023a\5,\27\2\u023a["+ - "\3\2\2\2\u023b\u023c\7c\2\2\u023c\u023d\7\32\2\2\u023d\u023e\5,\27\2\u023e"+ - "\u023f\7\u0080\2\2\u023f\u0240\5,\27\2\u0240\u0248\3\2\2\2\u0241\u0242"+ - "\5,\27\2\u0242\u0243\7\u0080\2\2\u0243\u0244\7c\2\2\u0244\u0245\7\32\2"+ - "\2\u0245\u0246\5,\27\2\u0246\u0248\3\2\2\2\u0247\u023b\3\2\2\2\u0247\u0241"+ - "\3\2\2\2\u0248]\3\2\2\2\u0249\u024a\7\u0085\2\2\u024a\u024b\5\\/\2\u024b"+ - "\u024c\7\u0086\2\2\u024c\u025e\3\2\2\2\u024d\u0256\7\u0085\2\2\u024e\u0253"+ - "\5,\27\2\u024f\u0250\7\u0083\2\2\u0250\u0252\5,\27\2\u0251\u024f\3\2\2"+ - "\2\u0252\u0255\3\2\2\2\u0253\u0251\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0257"+ - "\3\2\2\2\u0255\u0253\3\2\2\2\u0256\u024e\3\2\2\2\u0256\u0257\3\2\2\2\u0257"+ - "\u0258\3\2\2\2\u0258\u025e\7\u0086\2\2\u0259\u025a\7\u0085\2\2\u025a\u025b"+ - "\5Z.\2\u025b\u025c\7\u0086\2\2\u025c\u025e\3\2\2\2\u025d\u0249\3\2\2\2"+ - "\u025d\u024d\3\2\2\2\u025d\u0259\3\2\2\2\u025e_\3\2\2\2\u025f\u0275\7"+ - "\'\2\2\u0260\u0261\7k\2\2\u0261\u0262\5\\/\2\u0262\u0263\7l\2\2\u0263"+ - "\u0275\3\2\2\2\u0264\u026d\7k\2\2\u0265\u026a\5,\27\2\u0266\u0267\7\u0083"+ - "\2\2\u0267\u0269\5,\27\2\u0268\u0266\3\2\2\2\u0269\u026c\3\2\2\2\u026a"+ - "\u0268\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026e\3\2\2\2\u026c\u026a\3\2"+ - "\2\2\u026d\u0265\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u026f\3\2\2\2\u026f"+ - "\u0275\7l\2\2\u0270\u0271\7k\2\2\u0271\u0272\5Z.\2\u0272\u0273\7l\2\2"+ - "\u0273\u0275\3\2\2\2\u0274\u025f\3\2\2\2\u0274\u0260\3\2\2\2\u0274\u0264"+ - "\3\2\2\2\u0274\u0270\3\2\2\2\u0275a\3\2\2\2\u0276\u0278\7\u0081\2\2\u0277"+ - "\u0279\5d\63\2\u0278\u0277\3\2\2\2\u0279\u027a\3\2\2\2\u027a\u0278\3\2"+ - "\2\2\u027a\u027b\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u027d\7\u0082\2\2\u027d"+ - "\u0285\3\2\2\2\u027e\u0283\7(\2\2\u027f\u0280\7\u0081\2\2\u0280\u0281"+ - "\7Y\2\2\u0281\u0283\7\u0082\2\2\u0282\u027e\3\2\2\2\u0282\u027f\3\2\2"+ - "\2\u0283\u0285\3\2\2\2\u0284\u0276\3\2\2\2\u0284\u0282\3\2\2\2\u0285c"+ - "\3\2\2\2\u0286\u0287\7c\2\2\u0287\u0288\7Y\2\2\u0288\u0289\5,\27\2\u0289"+ - "e\3\2\2\2\u028a\u02a0\7&\2\2\u028b\u028c\7\u0081\2\2\u028c\u028d\5\\/"+ - "\2\u028d\u028e\7\u0082\2\2\u028e\u02a0\3\2\2\2\u028f\u0298\7\u0081\2\2"+ - "\u0290\u0295\5,\27\2\u0291\u0292\7\u0083\2\2\u0292\u0294\5,\27\2\u0293"+ - "\u0291\3\2\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2"+ - "\2\2\u0296\u0299\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0290\3\2\2\2\u0298"+ - "\u0299\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u02a0\7\u0082\2\2\u029b\u029c"+ - "\7\u0081\2\2\u029c\u029d\5Z.\2\u029d\u029e\7\u0082\2\2\u029e\u02a0\3\2"+ - "\2\2\u029f\u028a\3\2\2\2\u029f\u028b\3\2\2\2\u029f\u028f\3\2\2\2\u029f"+ - "\u029b\3\2\2\2\u02a0g\3\2\2\2\u02a1\u02b0\5j\66\2\u02a2\u02a3\7c\2\2\u02a3"+ - "\u02ac\7w\2\2\u02a4\u02a9\5,\27\2\u02a5\u02a6\7\u0083\2\2\u02a6\u02a8"+ - "\5,\27\2\u02a7\u02a5\3\2\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02a7\3\2\2\2\u02a9"+ - "\u02aa\3\2\2\2\u02aa\u02ad\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ac\u02a4\3\2"+ - "\2\2\u02ac\u02ad\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02b0\7x\2\2\u02af"+ - "\u02a1\3\2\2\2\u02af\u02a2\3\2\2\2\u02b0i\3\2\2\2\u02b1\u02b2\5p9\2\u02b2"+ - "\u02bb\7w\2\2\u02b3\u02b8\5,\27\2\u02b4\u02b5\7\u0083\2\2\u02b5\u02b7"+ - "\5,\27\2\u02b6\u02b4\3\2\2\2\u02b7\u02ba\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b8"+ - "\u02b9\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba\u02b8\3\2\2\2\u02bb\u02b3\3\2"+ - "\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02be\7x\2\2\u02be"+ - "k\3\2\2\2\u02bf\u02c0\5r:\2\u02c0\u02c9\7w\2\2\u02c1\u02c6\5,\27\2\u02c2"+ - "\u02c3\7\u0083\2\2\u02c3\u02c5\5,\27\2\u02c4\u02c2\3\2\2\2\u02c5\u02c8"+ - "\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02ca\3\2\2\2\u02c8"+ - "\u02c6\3\2\2\2\u02c9\u02c1\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca\u02cb\3\2"+ - "\2\2\u02cb\u02cc\7x\2\2\u02ccm\3\2\2\2\u02cd\u02db\7C\2\2\u02ce\u02db"+ - "\7D\2\2\u02cf\u02db\7A\2\2\u02d0\u02d1\79\2\2\u02d1\u02d2\7k\2\2\u02d2"+ - "\u02d3\5n8\2\u02d3\u02d4\7l\2\2\u02d4\u02db\3\2\2\2\u02d5\u02d6\7:\2\2"+ - "\u02d6\u02d7\7k\2\2\u02d7\u02d8\5n8\2\u02d8\u02d9\7l\2\2\u02d9\u02db\3"+ - "\2\2\2\u02da\u02cd\3\2\2\2\u02da\u02ce\3\2\2\2\u02da\u02cf\3\2\2\2\u02da"+ - "\u02d0\3\2\2\2\u02da\u02d5\3\2\2\2\u02dbo\3\2\2\2\u02dc\u02dd\t\r\2\2"+ - "\u02ddq\3\2\2\2\u02de\u02df\t\16\2\2\u02dfs\3\2\2\2\u02e0\u02e1\7c\2\2"+ - "\u02e1\u02e2\7\22\2\2\u02e2\u02e4\5,\27\2\u02e3\u02e0\3\2\2\2\u02e4\u02e7"+ - "\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e8\3\2\2\2\u02e7"+ - "\u02e5\3\2\2\2\u02e8\u02e9\7\2\2\3\u02e9u\3\2\2\2Gw~\u0083\u00ac\u00ba"+ - "\u00c3\u00d8\u00e2\u00e9\u00f3\u00fc\u00ff\u0111\u012a\u012d\u0132\u013a"+ - "\u013d\u0143\u014a\u0154\u0159\u016d\u017d\u0184\u018b\u0193\u019a\u01a2"+ - "\u01aa\u01b2\u01ba\u01c2\u01ca\u01d2\u01da\u01e2\u01ea\u01f2\u01f8\u0209"+ - "\u020b\u021b\u0221\u0228\u022e\u0234\u0247\u0253\u0256\u025d\u026a\u026d"+ - "\u0274\u027a\u0282\u0284\u0295\u0298\u029f\u02a9\u02ac\u02af\u02b8\u02bb"+ - "\u02c6\u02c9\u02da\u02e5"; + "\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00b1\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3"+ + "\7\3\7\3\7\7\7\u00bd\n\7\f\7\16\7\u00c0\13\7\3\b\3\b\3\b\3\b\7\b\u00c6"+ + "\n\b\f\b\16\b\u00c9\13\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\13\3\13"+ + "\3\13\3\13\3\13\3\13\3\13\3\f\3\f\5\f\u00dd\n\f\3\f\3\f\3\r\3\r\3\r\3"+ + "\r\3\r\3\r\5\r\u00e7\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u00ee\n\r\3\16\3\16\3"+ + "\16\3\16\3\16\3\16\7\16\u00f6\n\16\f\16\16\16\u00f9\13\16\3\16\3\16\3"+ + "\16\3\16\7\16\u00ff\n\16\f\16\16\16\u0102\13\16\5\16\u0104\n\16\3\16\3"+ + "\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3"+ + "\20\5\20\u0116\n\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+ + "\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\7\23\u012d\n\23"+ + "\f\23\16\23\u0130\13\23\5\23\u0132\n\23\3\23\3\23\3\23\5\23\u0137\n\23"+ + "\3\23\3\23\3\23\3\23\7\23\u013d\n\23\f\23\16\23\u0140\13\23\5\23\u0142"+ + "\n\23\3\23\3\23\7\23\u0146\n\23\f\23\16\23\u0149\13\23\3\23\3\23\7\23"+ + "\u014d\n\23\f\23\16\23\u0150\13\23\3\23\3\23\3\24\3\24\3\25\3\25\3\26"+ + "\5\26\u0159\n\26\3\26\3\26\3\26\5\26\u015e\n\26\3\27\3\27\3\27\3\27\3"+ + "\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u0170"+ + "\n\27\f\27\16\27\u0173\13\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3"+ + "\27\3\27\3\27\7\27\u0180\n\27\f\27\16\27\u0183\13\27\3\27\3\27\3\27\3"+ + "\27\5\27\u0189\n\27\3\30\3\30\3\30\3\30\3\30\5\30\u0190\n\30\3\31\3\31"+ + "\3\31\3\31\3\31\3\31\5\31\u0198\n\31\3\32\3\32\3\32\7\32\u019d\n\32\f"+ + "\32\16\32\u01a0\13\32\3\33\3\33\3\33\7\33\u01a5\n\33\f\33\16\33\u01a8"+ + "\13\33\3\34\3\34\3\34\7\34\u01ad\n\34\f\34\16\34\u01b0\13\34\3\35\3\35"+ + "\3\35\7\35\u01b5\n\35\f\35\16\35\u01b8\13\35\3\36\3\36\3\36\7\36\u01bd"+ + "\n\36\f\36\16\36\u01c0\13\36\3\37\3\37\3\37\7\37\u01c5\n\37\f\37\16\37"+ + "\u01c8\13\37\3 \3 \3 \7 \u01cd\n \f \16 \u01d0\13 \3!\3!\3!\7!\u01d5\n"+ + "!\f!\16!\u01d8\13!\3\"\3\"\3\"\7\"\u01dd\n\"\f\"\16\"\u01e0\13\"\3#\3"+ + "#\3#\7#\u01e5\n#\f#\16#\u01e8\13#\3$\3$\3$\7$\u01ed\n$\f$\16$\u01f0\13"+ + "$\3%\3%\3%\3%\3%\5%\u01f7\n%\3&\3&\7&\u01fb\n&\f&\16&\u01fe\13&\3\'\3"+ + "\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\7\'\u020e\n\'\f\'\16"+ + "\'\u0211\13\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\5(\u0220\n(\3)\3"+ + ")\3*\3*\5*\u0226\n*\3+\3+\3+\3+\3+\5+\u022d\n+\3,\3,\3,\3,\5,\u0233\n"+ + ",\3-\3-\3-\3-\3-\5-\u023a\n-\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3"+ + "/\3/\3/\3/\5/\u024d\n/\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\7\60\u0257"+ + "\n\60\f\60\16\60\u025a\13\60\5\60\u025c\n\60\3\60\3\60\3\60\3\60\3\60"+ + "\5\60\u0263\n\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\7\61\u026e"+ + "\n\61\f\61\16\61\u0271\13\61\5\61\u0273\n\61\3\61\3\61\3\61\3\61\3\61"+ + "\5\61\u027a\n\61\3\62\3\62\6\62\u027e\n\62\r\62\16\62\u027f\3\62\3\62"+ + "\3\62\3\62\3\62\3\62\5\62\u0288\n\62\5\62\u028a\n\62\3\63\3\63\3\63\3"+ + "\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u0299\n\64\f\64"+ + "\16\64\u029c\13\64\5\64\u029e\n\64\3\64\3\64\3\64\3\64\3\64\5\64\u02a5"+ + "\n\64\3\65\3\65\3\65\3\65\5\65\u02ab\n\65\3\65\3\65\6\65\u02af\n\65\r"+ + "\65\16\65\u02b0\3\65\3\65\5\65\u02b5\n\65\3\66\3\66\3\66\3\66\3\67\3\67"+ + "\3\67\3\67\3\67\3\67\7\67\u02c1\n\67\f\67\16\67\u02c4\13\67\5\67\u02c6"+ + "\n\67\3\67\5\67\u02c9\n\67\38\38\38\38\38\78\u02d0\n8\f8\168\u02d3\13"+ + "8\58\u02d5\n8\38\38\39\39\39\39\39\79\u02de\n9\f9\169\u02e1\139\59\u02e3"+ + "\n9\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\5:\u02f4\n:\3;\3;\3<"+ + "\3<\3=\3=\3=\7=\u02fd\n=\f=\16=\u0300\13=\3=\3=\3=\2\3L>\2\4\6\b\n\f\16"+ + "\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd"+ + "fhjlnprtvx\2\17\3\2*+\3\2pq\3\2lo\3\2^`\4\2--\u0081\u0081\3\2z{\4\2hi"+ + "st\3\2uw\4\2efjk\4\2su~~\3\2ef\b\2.9BBDDFFNNTW\b\2<<>>@ACCGMOS\2\u0338"+ + "\2{\3\2\2\2\4\u0080\3\2\2\2\6\u00b0\3\2\2\2\b\u00b2\3\2\2\2\n\u00b5\3"+ + "\2\2\2\f\u00b8\3\2\2\2\16\u00c1\3\2\2\2\20\u00ca\3\2\2\2\22\u00cf\3\2"+ + "\2\2\24\u00d3\3\2\2\2\26\u00da\3\2\2\2\30\u00ed\3\2\2\2\32\u00ef\3\2\2"+ + "\2\34\u0107\3\2\2\2\36\u010e\3\2\2\2 \u0117\3\2\2\2\"\u0121\3\2\2\2$\u0127"+ + "\3\2\2\2&\u0153\3\2\2\2(\u0155\3\2\2\2*\u0158\3\2\2\2,\u0188\3\2\2\2."+ + "\u018f\3\2\2\2\60\u0191\3\2\2\2\62\u0199\3\2\2\2\64\u01a1\3\2\2\2\66\u01a9"+ + "\3\2\2\28\u01b1\3\2\2\2:\u01b9\3\2\2\2<\u01c1\3\2\2\2>\u01c9\3\2\2\2@"+ + "\u01d1\3\2\2\2B\u01d9\3\2\2\2D\u01e1\3\2\2\2F\u01e9\3\2\2\2H\u01f6\3\2"+ + "\2\2J\u01f8\3\2\2\2L\u01ff\3\2\2\2N\u021f\3\2\2\2P\u0221\3\2\2\2R\u0225"+ + "\3\2\2\2T\u022c\3\2\2\2V\u0232\3\2\2\2X\u0239\3\2\2\2Z\u023b\3\2\2\2\\"+ + "\u024c\3\2\2\2^\u0262\3\2\2\2`\u0279\3\2\2\2b\u0289\3\2\2\2d\u028b\3\2"+ + "\2\2f\u02a4\3\2\2\2h\u02b4\3\2\2\2j\u02b6\3\2\2\2l\u02c8\3\2\2\2n\u02ca"+ + "\3\2\2\2p\u02d8\3\2\2\2r\u02f3\3\2\2\2t\u02f5\3\2\2\2v\u02f7\3\2\2\2x"+ + "\u02fe\3\2\2\2z|\5\4\3\2{z\3\2\2\2{|\3\2\2\2|}\3\2\2\2}~\7\2\2\3~\3\3"+ + "\2\2\2\177\u0081\5\6\4\2\u0080\177\3\2\2\2\u0081\u0082\3\2\2\2\u0082\u0080"+ + "\3\2\2\2\u0082\u0083\3\2\2\2\u0083\5\3\2\2\2\u0084\u00b1\5$\23\2\u0085"+ + "\u0087\7 \2\2\u0086\u0088\5,\27\2\u0087\u0086\3\2\2\2\u0087\u0088\3\2"+ + "\2\2\u0088\u0089\3\2\2\2\u0089\u00b1\7\177\2\2\u008a\u008b\5\30\r\2\u008b"+ + "\u008c\7\177\2\2\u008c\u00b1\3\2\2\2\u008d\u008e\7!\2\2\u008e\u00b1\7"+ + "\177\2\2\u008f\u0090\7#\2\2\u0090\u00b1\7\177\2\2\u0091\u0092\7$\2\2\u0092"+ + "\u00b1\7\177\2\2\u0093\u0094\7%\2\2\u0094\u00b1\7\177\2\2\u0095\u00b1"+ + "\5\26\f\2\u0096\u00b1\5\22\n\2\u0097\u0098\5\24\13\2\u0098\u0099\7\177"+ + "\2\2\u0099\u00b1\3\2\2\2\u009a\u00b1\5\32\16\2\u009b\u009c\5\34\17\2\u009c"+ + "\u009d\7\177\2\2\u009d\u00b1\3\2\2\2\u009e\u00b1\5\36\20\2\u009f\u00b1"+ + "\5 \21\2\u00a0\u00b1\5\"\22\2\u00a1\u00a2\5,\27\2\u00a2\u00a3\7\177\2"+ + "\2\u00a3\u00b1\3\2\2\2\u00a4\u00a5\5\16\b\2\u00a5\u00a6\7\177\2\2\u00a6"+ + "\u00b1\3\2\2\2\u00a7\u00a8\5\f\7\2\u00a8\u00a9\7\177\2\2\u00a9\u00b1\3"+ + "\2\2\2\u00aa\u00ab\5\b\5\2\u00ab\u00ac\7\177\2\2\u00ac\u00b1\3\2\2\2\u00ad"+ + "\u00ae\5\n\6\2\u00ae\u00af\7\177\2\2\u00af\u00b1\3\2\2\2\u00b0\u0084\3"+ + "\2\2\2\u00b0\u0085\3\2\2\2\u00b0\u008a\3\2\2\2\u00b0\u008d\3\2\2\2\u00b0"+ + "\u008f\3\2\2\2\u00b0\u0091\3\2\2\2\u00b0\u0093\3\2\2\2\u00b0\u0095\3\2"+ + "\2\2\u00b0\u0096\3\2\2\2\u00b0\u0097\3\2\2\2\u00b0\u009a\3\2\2\2\u00b0"+ + "\u009b\3\2\2\2\u00b0\u009e\3\2\2\2\u00b0\u009f\3\2\2\2\u00b0\u00a0\3\2"+ + "\2\2\u00b0\u00a1\3\2\2\2\u00b0\u00a4\3\2\2\2\u00b0\u00a7\3\2\2\2\u00b0"+ + "\u00aa\3\2\2\2\u00b0\u00ad\3\2\2\2\u00b1\7\3\2\2\2\u00b2\u00b3\7\7\2\2"+ + "\u00b3\u00b4\5,\27\2\u00b4\t\3\2\2\2\u00b5\u00b6\7\6\2\2\u00b6\u00b7\5"+ + ",\27\2\u00b7\13\3\2\2\2\u00b8\u00b9\7\34\2\2\u00b9\u00be\7d\2\2\u00ba"+ + "\u00bb\7\u0084\2\2\u00bb\u00bd\7d\2\2\u00bc\u00ba\3\2\2\2\u00bd\u00c0"+ + "\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\r\3\2\2\2\u00c0"+ + "\u00be\3\2\2\2\u00c1\u00c2\7\b\2\2\u00c2\u00c7\5\20\t\2\u00c3\u00c4\7"+ + "\u0084\2\2\u00c4\u00c6\5\20\t\2\u00c5\u00c3\3\2\2\2\u00c6\u00c9\3\2\2"+ + "\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\17\3\2\2\2\u00c9\u00c7"+ + "\3\2\2\2\u00ca\u00cb\7Y\2\2\u00cb\u00cc\7d\2\2\u00cc\u00cd\7\u0080\2\2"+ + "\u00cd\u00ce\5r:\2\u00ce\21\3\2\2\2\u00cf\u00d0\7[\2\2\u00d0\u00d1\7,"+ + "\2\2\u00d1\u00d2\7\u008a\2\2\u00d2\23\3\2\2\2\u00d3\u00d4\7\37\2\2\u00d4"+ + "\u00d5\5\6\4\2\u00d5\u00d6\7\"\2\2\u00d6\u00d7\7x\2\2\u00d7\u00d8\5,\27"+ + "\2\u00d8\u00d9\7y\2\2\u00d9\25\3\2\2\2\u00da\u00dc\7\u0082\2\2\u00db\u00dd"+ + "\5\4\3\2\u00dc\u00db\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\u00de\3\2\2\2\u00de"+ + "\u00df\7\u0083\2\2\u00df\27\3\2\2\2\u00e0\u00e1\7\35\2\2\u00e1\u00e2\5"+ + ",\27\2\u00e2\u00e3\7\32\2\2\u00e3\u00e6\5,\27\2\u00e4\u00e5\7X\2\2\u00e5"+ + "\u00e7\5,\27\2\u00e6\u00e4\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00ee\3\2"+ + "\2\2\u00e8\u00e9\7\36\2\2\u00e9\u00ea\5,\27\2\u00ea\u00eb\7\32\2\2\u00eb"+ + "\u00ec\5,\27\2\u00ec\u00ee\3\2\2\2\u00ed\u00e0\3\2\2\2\u00ed\u00e8\3\2"+ + "\2\2\u00ee\31\3\2\2\2\u00ef\u00f0\7\25\2\2\u00f0\u00f1\7x\2\2\u00f1\u00f2"+ + "\5,\27\2\u00f2\u00f7\7y\2\2\u00f3\u00f4\7\t\2\2\u00f4\u00f6\5,\27\2\u00f5"+ + "\u00f3\3\2\2\2\u00f6\u00f9\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f8\3\2"+ + "\2\2\u00f8\u0103\3\2\2\2\u00f9\u00f7\3\2\2\2\u00fa\u00fb\t\2\2\2\u00fb"+ + "\u0100\7d\2\2\u00fc\u00fd\7\u0084\2\2\u00fd\u00ff\7d\2\2\u00fe\u00fc\3"+ + "\2\2\2\u00ff\u0102\3\2\2\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101"+ + "\u0104\3\2\2\2\u0102\u0100\3\2\2\2\u0103\u00fa\3\2\2\2\u0103\u0104\3\2"+ + "\2\2\u0104\u0105\3\2\2\2\u0105\u0106\5\6\4\2\u0106\33\3\2\2\2\u0107\u0108"+ + "\7\26\2\2\u0108\u0109\5\6\4\2\u0109\u010a\7\25\2\2\u010a\u010b\7x\2\2"+ + "\u010b\u010c\5,\27\2\u010c\u010d\7y\2\2\u010d\35\3\2\2\2\u010e\u010f\7"+ + "\23\2\2\u010f\u0110\7x\2\2\u0110\u0111\5,\27\2\u0111\u0112\7y\2\2\u0112"+ + "\u0115\5\6\4\2\u0113\u0114\7\24\2\2\u0114\u0116\5\6\4\2\u0115\u0113\3"+ + "\2\2\2\u0115\u0116\3\2\2\2\u0116\37\3\2\2\2\u0117\u0118\7\27\2\2\u0118"+ + "\u0119\7x\2\2\u0119\u011a\5,\27\2\u011a\u011b\7\177\2\2\u011b\u011c\5"+ + ",\27\2\u011c\u011d\7\177\2\2\u011d\u011e\5,\27\2\u011e\u011f\7y\2\2\u011f"+ + "\u0120\5\6\4\2\u0120!\3\2\2\2\u0121\u0122\7\30\2\2\u0122\u0123\7d\2\2"+ + "\u0123\u0124\7\32\2\2\u0124\u0125\5,\27\2\u0125\u0126\5\6\4\2\u0126#\3"+ + "\2\2\2\u0127\u0128\7d\2\2\u0128\u0131\7x\2\2\u0129\u012e\5*\26\2\u012a"+ + "\u012b\7\u0084\2\2\u012b\u012d\5*\26\2\u012c\u012a\3\2\2\2\u012d\u0130"+ + "\3\2\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f\u0132\3\2\2\2\u0130"+ + "\u012e\3\2\2\2\u0131\u0129\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133\3\2"+ + "\2\2\u0133\u0136\7y\2\2\u0134\u0135\7\u0080\2\2\u0135\u0137\5r:\2\u0136"+ + "\u0134\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0141\3\2\2\2\u0138\u0139\t\2"+ + "\2\2\u0139\u013e\7d\2\2\u013a\u013b\7\u0084\2\2\u013b\u013d\7d\2\2\u013c"+ + "\u013a\3\2\2\2\u013d\u0140\3\2\2\2\u013e\u013c\3\2\2\2\u013e\u013f\3\2"+ + "\2\2\u013f\u0142\3\2\2\2\u0140\u013e\3\2\2\2\u0141\u0138\3\2\2\2\u0141"+ + "\u0142\3\2\2\2\u0142\u0147\3\2\2\2\u0143\u0144\7\n\2\2\u0144\u0146\5&"+ + "\24\2\u0145\u0143\3\2\2\2\u0146\u0149\3\2\2\2\u0147\u0145\3\2\2\2\u0147"+ + "\u0148\3\2\2\2\u0148\u014e\3\2\2\2\u0149\u0147\3\2\2\2\u014a\u014b\7\13"+ + "\2\2\u014b\u014d\5(\25\2\u014c\u014a\3\2\2\2\u014d\u0150\3\2\2\2\u014e"+ + "\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151\3\2\2\2\u0150\u014e\3\2"+ + "\2\2\u0151\u0152\5\26\f\2\u0152%\3\2\2\2\u0153\u0154\5,\27\2\u0154\'\3"+ + "\2\2\2\u0155\u0156\5,\27\2\u0156)\3\2\2\2\u0157\u0159\7\33\2\2\u0158\u0157"+ + "\3\2\2\2\u0158\u0159\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015d\7d\2\2\u015b"+ + "\u015c\7\u0080\2\2\u015c\u015e\5r:\2\u015d\u015b\3\2\2\2\u015d\u015e\3"+ + "\2\2\2\u015e+\3\2\2\2\u015f\u0160\5.\30\2\u0160\u0161\7\r\2\2\u0161\u0162"+ + "\5,\27\2\u0162\u0189\3\2\2\2\u0163\u0164\5.\30\2\u0164\u0165\7\16\2\2"+ + "\u0165\u0166\5,\27\2\u0166\u0189\3\2\2\2\u0167\u0168\7\17\2\2\u0168\u0169"+ + "\7d\2\2\u0169\u016a\7\u0080\2\2\u016a\u0171\5r:\2\u016b\u016c\7\u0084"+ + "\2\2\u016c\u016d\7d\2\2\u016d\u016e\7\u0080\2\2\u016e\u0170\5r:\2\u016f"+ + "\u016b\3\2\2\2\u0170\u0173\3\2\2\2\u0171\u016f\3\2\2\2\u0171\u0172\3\2"+ + "\2\2\u0172\u0174\3\2\2\2\u0173\u0171\3\2\2\2\u0174\u0175\7\21\2\2\u0175"+ + "\u0176\5,\27\2\u0176\u0189\3\2\2\2\u0177\u0178\7\20\2\2\u0178\u0179\7"+ + "d\2\2\u0179\u017a\7\u0080\2\2\u017a\u0181\5r:\2\u017b\u017c\7\u0084\2"+ + "\2\u017c\u017d\7d\2\2\u017d\u017e\7\u0080\2\2\u017e\u0180\5r:\2\u017f"+ + "\u017b\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ + "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\7\21\2\2\u0185"+ + "\u0186\5,\27\2\u0186\u0189\3\2\2\2\u0187\u0189\5.\30\2\u0188\u015f\3\2"+ + "\2\2\u0188\u0163\3\2\2\2\u0188\u0167\3\2\2\2\u0188\u0177\3\2\2\2\u0188"+ + "\u0187\3\2\2\2\u0189-\3\2\2\2\u018a\u018b\5L\'\2\u018b\u018c\7r\2\2\u018c"+ + "\u018d\5,\27\2\u018d\u0190\3\2\2\2\u018e\u0190\5\60\31\2\u018f\u018a\3"+ + "\2\2\2\u018f\u018e\3\2\2\2\u0190/\3\2\2\2\u0191\u0197\5\62\32\2\u0192"+ + "\u0193\7\u0089\2\2\u0193\u0194\5,\27\2\u0194\u0195\7\u0080\2\2\u0195\u0196"+ + "\5,\27\2\u0196\u0198\3\2\2\2\u0197\u0192\3\2\2\2\u0197\u0198\3\2\2\2\u0198"+ + "\61\3\2\2\2\u0199\u019e\5\64\33\2\u019a\u019b\7|\2\2\u019b\u019d\5\64"+ + "\33\2\u019c\u019a\3\2\2\2\u019d\u01a0\3\2\2\2\u019e\u019c\3\2\2\2\u019e"+ + "\u019f\3\2\2\2\u019f\63\3\2\2\2\u01a0\u019e\3\2\2\2\u01a1\u01a6\5\66\34"+ + "\2\u01a2\u01a3\7}\2\2\u01a3\u01a5\5\66\34\2\u01a4\u01a2\3\2\2\2\u01a5"+ + "\u01a8\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7\65\3\2\2"+ + "\2\u01a8\u01a6\3\2\2\2\u01a9\u01ae\58\35\2\u01aa\u01ab\7\31\2\2\u01ab"+ + "\u01ad\58\35\2\u01ac\u01aa\3\2\2\2\u01ad\u01b0\3\2\2\2\u01ae\u01ac\3\2"+ + "\2\2\u01ae\u01af\3\2\2\2\u01af\67\3\2\2\2\u01b0\u01ae\3\2\2\2\u01b1\u01b6"+ + "\5:\36\2\u01b2\u01b3\t\3\2\2\u01b3\u01b5\5:\36\2\u01b4\u01b2\3\2\2\2\u01b5"+ + "\u01b8\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b79\3\2\2\2"+ + "\u01b8\u01b6\3\2\2\2\u01b9\u01be\5<\37\2\u01ba\u01bb\t\4\2\2\u01bb\u01bd"+ + "\5<\37\2\u01bc\u01ba\3\2\2\2\u01bd\u01c0\3\2\2\2\u01be\u01bc\3\2\2\2\u01be"+ + "\u01bf\3\2\2\2\u01bf;\3\2\2\2\u01c0\u01be\3\2\2\2\u01c1\u01c6\5> \2\u01c2"+ + "\u01c3\t\5\2\2\u01c3\u01c5\5> \2\u01c4\u01c2\3\2\2\2\u01c5\u01c8\3\2\2"+ + "\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7=\3\2\2\2\u01c8\u01c6"+ + "\3\2\2\2\u01c9\u01ce\5@!\2\u01ca\u01cb\t\6\2\2\u01cb\u01cd\5@!\2\u01cc"+ + "\u01ca\3\2\2\2\u01cd\u01d0\3\2\2\2\u01ce\u01cc\3\2\2\2\u01ce\u01cf\3\2"+ + "\2\2\u01cf?\3\2\2\2\u01d0\u01ce\3\2\2\2\u01d1\u01d6\5B\"\2\u01d2\u01d3"+ + "\7g\2\2\u01d3\u01d5\5B\"\2\u01d4\u01d2\3\2\2\2\u01d5\u01d8\3\2\2\2\u01d6"+ + "\u01d4\3\2\2\2\u01d6\u01d7\3\2\2\2\u01d7A\3\2\2\2\u01d8\u01d6\3\2\2\2"+ + "\u01d9\u01de\5D#\2\u01da\u01db\t\7\2\2\u01db\u01dd\5D#\2\u01dc\u01da\3"+ + "\2\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2\2\u01de\u01df\3\2\2\2\u01df"+ + "C\3\2\2\2\u01e0\u01de\3\2\2\2\u01e1\u01e6\5F$\2\u01e2\u01e3\t\b\2\2\u01e3"+ + "\u01e5\5F$\2\u01e4\u01e2\3\2\2\2\u01e5\u01e8\3\2\2\2\u01e6\u01e4\3\2\2"+ + "\2\u01e6\u01e7\3\2\2\2\u01e7E\3\2\2\2\u01e8\u01e6\3\2\2\2\u01e9\u01ee"+ + "\5H%\2\u01ea\u01eb\t\t\2\2\u01eb\u01ed\5H%\2\u01ec\u01ea\3\2\2\2\u01ed"+ + "\u01f0\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ee\u01ef\3\2\2\2\u01efG\3\2\2\2"+ + "\u01f0\u01ee\3\2\2\2\u01f1\u01f2\t\n\2\2\u01f2\u01f7\5H%\2\u01f3\u01f4"+ + "\t\13\2\2\u01f4\u01f7\5H%\2\u01f5\u01f7\5J&\2\u01f6\u01f1\3\2\2\2\u01f6"+ + "\u01f3\3\2\2\2\u01f6\u01f5\3\2\2\2\u01f7I\3\2\2\2\u01f8\u01fc\5L\'\2\u01f9"+ + "\u01fb\t\f\2\2\u01fa\u01f9\3\2\2\2\u01fb\u01fe\3\2\2\2\u01fc\u01fa\3\2"+ + "\2\2\u01fc\u01fd\3\2\2\2\u01fdK\3\2\2\2\u01fe\u01fc\3\2\2\2\u01ff\u0200"+ + "\b\'\1\2\u0200\u0201\5N(\2\u0201\u020f\3\2\2\2\u0202\u0203\f\6\2\2\u0203"+ + "\u0204\7\u0085\2\2\u0204\u020e\5p9\2\u0205\u0206\f\5\2\2\u0206\u0207\7"+ + "\u0085\2\2\u0207\u020e\7d\2\2\u0208\u0209\f\4\2\2\u0209\u020a\7\u0086"+ + "\2\2\u020a\u020b\5,\27\2\u020b\u020c\7\u0087\2\2\u020c\u020e\3\2\2\2\u020d"+ + "\u0202\3\2\2\2\u020d\u0205\3\2\2\2\u020d\u0208\3\2\2\2\u020e\u0211\3\2"+ + "\2\2\u020f\u020d\3\2\2\2\u020f\u0210\3\2\2\2\u0210M\3\2\2\2\u0211\u020f"+ + "\3\2\2\2\u0212\u0220\7\f\2\2\u0213\u0220\5V,\2\u0214\u0220\5R*\2\u0215"+ + "\u0216\7x\2\2\u0216\u0217\5,\27\2\u0217\u0218\7y\2\2\u0218\u0220\3\2\2"+ + "\2\u0219\u021a\7\\\2\2\u021a\u021b\5P)\2\u021b\u021c\7x\2\2\u021c\u021d"+ + "\5,\27\2\u021d\u021e\7y\2\2\u021e\u0220\3\2\2\2\u021f\u0212\3\2\2\2\u021f"+ + "\u0213\3\2\2\2\u021f\u0214\3\2\2\2\u021f\u0215\3\2\2\2\u021f\u0219\3\2"+ + "\2\2\u0220O\3\2\2\2\u0221\u0222\7]\2\2\u0222Q\3\2\2\2\u0223\u0226\5T+"+ + "\2\u0224\u0226\5X-\2\u0225\u0223\3\2\2\2\u0225\u0224\3\2\2\2\u0226S\3"+ + "\2\2\2\u0227\u022d\7a\2\2\u0228\u022d\7b\2\2\u0229\u022d\7c\2\2\u022a"+ + "\u022d\7\u008a\2\2\u022b\u022d\7\u0089\2\2\u022c\u0227\3\2\2\2\u022c\u0228"+ + "\3\2\2\2\u022c\u0229\3\2\2\2\u022c\u022a\3\2\2\2\u022c\u022b\3\2\2\2\u022d"+ + "U\3\2\2\2\u022e\u0233\5l\67\2\u022f\u0233\7d\2\2\u0230\u0231\7Y\2\2\u0231"+ + "\u0233\7d\2\2\u0232\u022e\3\2\2\2\u0232\u022f\3\2\2\2\u0232\u0230\3\2"+ + "\2\2\u0233W\3\2\2\2\u0234\u023a\5^\60\2\u0235\u023a\5`\61\2\u0236\u023a"+ + "\5f\64\2\u0237\u023a\5b\62\2\u0238\u023a\5h\65\2\u0239\u0234\3\2\2\2\u0239"+ + "\u0235\3\2\2\2\u0239\u0236\3\2\2\2\u0239\u0237\3\2\2\2\u0239\u0238\3\2"+ + "\2\2\u023aY\3\2\2\2\u023b\u023c\5,\27\2\u023c\u023d\7\u0085\2\2\u023d"+ + "\u023e\7\u0085\2\2\u023e\u023f\5,\27\2\u023f[\3\2\2\2\u0240\u0241\7d\2"+ + "\2\u0241\u0242\7\32\2\2\u0242\u0243\5,\27\2\u0243\u0244\7\u0081\2\2\u0244"+ + "\u0245\5,\27\2\u0245\u024d\3\2\2\2\u0246\u0247\5,\27\2\u0247\u0248\7\u0081"+ + "\2\2\u0248\u0249\7d\2\2\u0249\u024a\7\32\2\2\u024a\u024b\5,\27\2\u024b"+ + "\u024d\3\2\2\2\u024c\u0240\3\2\2\2\u024c\u0246\3\2\2\2\u024d]\3\2\2\2"+ + "\u024e\u024f\7\u0086\2\2\u024f\u0250\5\\/\2\u0250\u0251\7\u0087\2\2\u0251"+ + "\u0263\3\2\2\2\u0252\u025b\7\u0086\2\2\u0253\u0258\5,\27\2\u0254\u0255"+ + "\7\u0084\2\2\u0255\u0257\5,\27\2\u0256\u0254\3\2\2\2\u0257\u025a\3\2\2"+ + "\2\u0258\u0256\3\2\2\2\u0258\u0259\3\2\2\2\u0259\u025c\3\2\2\2\u025a\u0258"+ + "\3\2\2\2\u025b\u0253\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u025d\3\2\2\2\u025d"+ + "\u0263\7\u0087\2\2\u025e\u025f\7\u0086\2\2\u025f\u0260\5Z.\2\u0260\u0261"+ + "\7\u0087\2\2\u0261\u0263\3\2\2\2\u0262\u024e\3\2\2\2\u0262\u0252\3\2\2"+ + "\2\u0262\u025e\3\2\2\2\u0263_\3\2\2\2\u0264\u027a\7(\2\2\u0265\u0266\7"+ + "l\2\2\u0266\u0267\5\\/\2\u0267\u0268\7m\2\2\u0268\u027a\3\2\2\2\u0269"+ + "\u0272\7l\2\2\u026a\u026f\5,\27\2\u026b\u026c\7\u0084\2\2\u026c\u026e"+ + "\5,\27\2\u026d\u026b\3\2\2\2\u026e\u0271\3\2\2\2\u026f\u026d\3\2\2\2\u026f"+ + "\u0270\3\2\2\2\u0270\u0273\3\2\2\2\u0271\u026f\3\2\2\2\u0272\u026a\3\2"+ + "\2\2\u0272\u0273\3\2\2\2\u0273\u0274\3\2\2\2\u0274\u027a\7m\2\2\u0275"+ + "\u0276\7l\2\2\u0276\u0277\5Z.\2\u0277\u0278\7m\2\2\u0278\u027a\3\2\2\2"+ + "\u0279\u0264\3\2\2\2\u0279\u0265\3\2\2\2\u0279\u0269\3\2\2\2\u0279\u0275"+ + "\3\2\2\2\u027aa\3\2\2\2\u027b\u027d\7\u0082\2\2\u027c\u027e\5d\63\2\u027d"+ + "\u027c\3\2\2\2\u027e\u027f\3\2\2\2\u027f\u027d\3\2\2\2\u027f\u0280\3\2"+ + "\2\2\u0280\u0281\3\2\2\2\u0281\u0282\7\u0083\2\2\u0282\u028a\3\2\2\2\u0283"+ + "\u0288\7)\2\2\u0284\u0285\7\u0082\2\2\u0285\u0286\7Z\2\2\u0286\u0288\7"+ + "\u0083\2\2\u0287\u0283\3\2\2\2\u0287\u0284\3\2\2\2\u0288\u028a\3\2\2\2"+ + "\u0289\u027b\3\2\2\2\u0289\u0287\3\2\2\2\u028ac\3\2\2\2\u028b\u028c\7"+ + "d\2\2\u028c\u028d\7Z\2\2\u028d\u028e\5,\27\2\u028ee\3\2\2\2\u028f\u02a5"+ + "\7\'\2\2\u0290\u0291\7\u0082\2\2\u0291\u0292\5\\/\2\u0292\u0293\7\u0083"+ + "\2\2\u0293\u02a5\3\2\2\2\u0294\u029d\7\u0082\2\2\u0295\u029a\5,\27\2\u0296"+ + "\u0297\7\u0084\2\2\u0297\u0299\5,\27\2\u0298\u0296\3\2\2\2\u0299\u029c"+ + "\3\2\2\2\u029a\u0298\3\2\2\2\u029a\u029b\3\2\2\2\u029b\u029e\3\2\2\2\u029c"+ + "\u029a\3\2\2\2\u029d\u0295\3\2\2\2\u029d\u029e\3\2\2\2\u029e\u029f\3\2"+ + "\2\2\u029f\u02a5\7\u0083\2\2\u02a0\u02a1\7\u0082\2\2\u02a1\u02a2\5Z.\2"+ + "\u02a2\u02a3\7\u0083\2\2\u02a3\u02a5\3\2\2\2\u02a4\u028f\3\2\2\2\u02a4"+ + "\u0290\3\2\2\2\u02a4\u0294\3\2\2\2\u02a4\u02a0\3\2\2\2\u02a5g\3\2\2\2"+ + "\u02a6\u02ab\7&\2\2\u02a7\u02a8\7\u0082\2\2\u02a8\u02a9\7\22\2\2\u02a9"+ + "\u02ab\7\u0083\2\2\u02aa\u02a6\3\2\2\2\u02aa\u02a7\3\2\2\2\u02ab\u02b5"+ + "\3\2\2\2\u02ac\u02ae\7\u0082\2\2\u02ad\u02af\5j\66\2\u02ae\u02ad\3\2\2"+ + "\2\u02af\u02b0\3\2\2\2\u02b0\u02ae\3\2\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b2"+ + "\3\2\2\2\u02b2\u02b3\7\u0083\2\2\u02b3\u02b5\3\2\2\2\u02b4\u02aa\3\2\2"+ + "\2\u02b4\u02ac\3\2\2\2\u02b5i\3\2\2\2\u02b6\u02b7\5,\27\2\u02b7\u02b8"+ + "\7\22\2\2\u02b8\u02b9\5,\27\2\u02b9k\3\2\2\2\u02ba\u02c9\5n8\2\u02bb\u02bc"+ + "\7d\2\2\u02bc\u02c5\7x\2\2\u02bd\u02c2\5,\27\2\u02be\u02bf\7\u0084\2\2"+ + "\u02bf\u02c1\5,\27\2\u02c0\u02be\3\2\2\2\u02c1\u02c4\3\2\2\2\u02c2\u02c0"+ + "\3\2\2\2\u02c2\u02c3\3\2\2\2\u02c3\u02c6\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c5"+ + "\u02bd\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02c9\7y"+ + "\2\2\u02c8\u02ba\3\2\2\2\u02c8\u02bb\3\2\2\2\u02c9m\3\2\2\2\u02ca\u02cb"+ + "\5t;\2\u02cb\u02d4\7x\2\2\u02cc\u02d1\5,\27\2\u02cd\u02ce\7\u0084\2\2"+ + "\u02ce\u02d0\5,\27\2\u02cf\u02cd\3\2\2\2\u02d0\u02d3\3\2\2\2\u02d1\u02cf"+ + "\3\2\2\2\u02d1\u02d2\3\2\2\2\u02d2\u02d5\3\2\2\2\u02d3\u02d1\3\2\2\2\u02d4"+ + "\u02cc\3\2\2\2\u02d4\u02d5\3\2\2\2\u02d5\u02d6\3\2\2\2\u02d6\u02d7\7y"+ + "\2\2\u02d7o\3\2\2\2\u02d8\u02d9\5v<\2\u02d9\u02e2\7x\2\2\u02da\u02df\5"+ + ",\27\2\u02db\u02dc\7\u0084\2\2\u02dc\u02de\5,\27\2\u02dd\u02db\3\2\2\2"+ + "\u02de\u02e1\3\2\2\2\u02df\u02dd\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e3"+ + "\3\2\2\2\u02e1\u02df\3\2\2\2\u02e2\u02da\3\2\2\2\u02e2\u02e3\3\2\2\2\u02e3"+ + "\u02e4\3\2\2\2\u02e4\u02e5\7y\2\2\u02e5q\3\2\2\2\u02e6\u02f4\7D\2\2\u02e7"+ + "\u02f4\7E\2\2\u02e8\u02f4\7B\2\2\u02e9\u02ea\7:\2\2\u02ea\u02eb\7l\2\2"+ + "\u02eb\u02ec\5r:\2\u02ec\u02ed\7m\2\2\u02ed\u02f4\3\2\2\2\u02ee\u02ef"+ + "\7;\2\2\u02ef\u02f0\7l\2\2\u02f0\u02f1\5r:\2\u02f1\u02f2\7m\2\2\u02f2"+ + "\u02f4\3\2\2\2\u02f3\u02e6\3\2\2\2\u02f3\u02e7\3\2\2\2\u02f3\u02e8\3\2"+ + "\2\2\u02f3\u02e9\3\2\2\2\u02f3\u02ee\3\2\2\2\u02f4s\3\2\2\2\u02f5\u02f6"+ + "\t\r\2\2\u02f6u\3\2\2\2\u02f7\u02f8\t\16\2\2\u02f8w\3\2\2\2\u02f9\u02fa"+ + "\7d\2\2\u02fa\u02fb\7\22\2\2\u02fb\u02fd\5,\27\2\u02fc\u02f9\3\2\2\2\u02fd"+ + "\u0300\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0301\3\2"+ + "\2\2\u0300\u02fe\3\2\2\2\u0301\u0302\7\2\2\3\u0302y\3\2\2\2J{\u0082\u0087"+ + "\u00b0\u00be\u00c7\u00dc\u00e6\u00ed\u00f7\u0100\u0103\u0115\u012e\u0131"+ + "\u0136\u013e\u0141\u0147\u014e\u0158\u015d\u0171\u0181\u0188\u018f\u0197"+ + "\u019e\u01a6\u01ae\u01b6\u01be\u01c6\u01ce\u01d6\u01de\u01e6\u01ee\u01f6"+ + "\u01fc\u020d\u020f\u021f\u0225\u022c\u0232\u0239\u024c\u0258\u025b\u0262"+ + "\u026f\u0272\u0279\u027f\u0287\u0289\u029a\u029d\u02a4\u02aa\u02b0\u02b4"+ + "\u02c2\u02c5\u02c8\u02d1\u02d4\u02df\u02e2\u02f3\u02fe"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static { diff --git a/src/main/java/grammar/alkVisitor.java b/src/main/java/grammar/alkVisitor.java index 75696df4..12c63c5d 100644 --- a/src/main/java/grammar/alkVisitor.java +++ b/src/main/java/grammar/alkVisitor.java @@ -620,6 +620,13 @@ public interface alkVisitor extends ParseTreeVisitor { * @return the visitor result */ T visitStructureValue(alkParser.StructureValueContext ctx); + /** + * Visit a parse tree produced by the {@code MappingValue} + * labeled alternative in {@link alkParser#data_structure}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMappingValue(alkParser.MappingValueContext ctx); /** * Visit a parse tree produced by the {@code IntervalDefinition} * labeled alternative in {@link alkParser#interval}. @@ -739,6 +746,27 @@ public interface alkVisitor extends ParseTreeVisitor { * @return the visitor result */ T visitSetWithInterval(alkParser.SetWithIntervalContext ctx); + /** + * Visit a parse tree produced by the {@code EmptyMapping} + * labeled alternative in {@link alkParser#mapping}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEmptyMapping(alkParser.EmptyMappingContext ctx); + /** + * Visit a parse tree produced by the {@code MappingWithComponents} + * labeled alternative in {@link alkParser#mapping}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMappingWithComponents(alkParser.MappingWithComponentsContext ctx); + /** + * Visit a parse tree produced by the {@code MappingComponentDefinition} + * labeled alternative in {@link alkParser#mapping_component}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMappingComponentDefinition(alkParser.MappingComponentDefinitionContext ctx); /** * Visit a parse tree produced by the {@code ToBuiltinFunction} * labeled alternative in {@link alkParser#function_call}. diff --git a/src/main/java/grammar/parts/expression.g4 b/src/main/java/grammar/parts/expression.g4 index 4f30d40e..ac47dc5d 100644 --- a/src/main/java/grammar/parts/expression.g4 +++ b/src/main/java/grammar/parts/expression.g4 @@ -145,6 +145,7 @@ data_structure | list #ListValue | set #SetValue | structure #StructureValue + | mapping #MappingValue ; @@ -195,6 +196,14 @@ set: | LCB interval RCB #SetWithInterval ; +mapping: + (EMPTYMAP | LCB TO RCB) #EmptyMapping + | LCB (mapping_component)+ RCB #MappingWithComponents +; + +mapping_component: + expression TO expression #MappingComponentDefinition +; //Function function_call diff --git a/src/main/java/grammar/parts/terminal.g4 b/src/main/java/grammar/parts/terminal.g4 index ae25ccf7..334d96f7 100644 --- a/src/main/java/grammar/parts/terminal.g4 +++ b/src/main/java/grammar/parts/terminal.g4 @@ -55,6 +55,7 @@ FAILURE : 'failure'; CONTINUE: 'continue'; BREAK: 'break'; +EMPTYMAP : 'emptyMap'; EMPTYSET : 'emptySet'; EMPTYLIST : 'emptyList'; EMPTYSTRUCTURE : 'emptyStructure'; diff --git a/src/main/java/parser/ParseTreeExprVisitor.java b/src/main/java/parser/ParseTreeExprVisitor.java index 4e2a45cd..da497c19 100644 --- a/src/main/java/parser/ParseTreeExprVisitor.java +++ b/src/main/java/parser/ParseTreeExprVisitor.java @@ -476,6 +476,12 @@ public AST visitStructureValue(alkParser.StructureValueContext ctx) return new StructureVisitor(this).visit(ctx.structure()); } + @Override + public AST visitMappingValue(alkParser.MappingValueContext ctx) + { + return new MapVisitor(this).visit(ctx.mapping()); + } + @Override public AST visitIntType(alkParser.IntTypeContext ctx) { @@ -689,6 +695,7 @@ public AST visitSetWithSpec(alkParser.SetWithSpecContext ctx) return new DataStructureVisitor(parseTreeExprVisitor, ast).visit(ctx.spec()); } } + static class StructureVisitor extends alkBaseVisitor { private final ParseTreeExprVisitor parseTreeExprVisitor; @@ -731,6 +738,47 @@ public AST visitEmptyStructure(alkParser.EmptyStructureContext ctx) } } + static class MapVisitor extends alkBaseVisitor + { + private final ParseTreeExprVisitor parseTreeExprVisitor; + + public MapVisitor(ParseTreeExprVisitor parseTreeExprVisitor) + { + this.parseTreeExprVisitor = parseTreeExprVisitor; + } + + @Override + public AST visitMappingWithComponents(alkParser.MappingWithComponentsContext ctx) + { + AST strAST = new MapAST(ctx); + RepresentationASTAttr attr = new RepresentationASTAttr(CompoundValueRepresentation.COMPONENTS); + strAST.addAttribute(RepresentationASTAttr.class, attr); + + for (int i = 0; i < ctx.mapping_component().size(); i++) + strAST.addChild(visit(ctx.mapping_component(i))); + + return strAST; + } + + @Override + public AST visitMappingComponentDefinition(alkParser.MappingComponentDefinitionContext ctx) + { + AST comp = new ComponentAST(ctx); + comp.addChild(parseTreeExprVisitor.visit(ctx.expression(0))); + comp.addChild(parseTreeExprVisitor.visit(ctx.expression(1))); + return comp; + } + + @Override + public AST visitEmptyMapping(alkParser.EmptyMappingContext ctx) + { + AST strAST = new MapAST(ctx); + RepresentationASTAttr attr = new RepresentationASTAttr(CompoundValueRepresentation.EMPTY); + strAST.addAttribute(RepresentationASTAttr.class, attr); + return strAST; + } + } + static class DataStructureVisitor extends alkBaseVisitor { private final AST target; diff --git a/src/main/java/smt/SMTVisitor.java b/src/main/java/smt/SMTVisitor.java index 4490ced0..e4459d20 100644 --- a/src/main/java/smt/SMTVisitor.java +++ b/src/main/java/smt/SMTVisitor.java @@ -1,5 +1,6 @@ package smt; +import ast.VirtualAST; import ast.attr.*; import ast.enums.BuiltInMethod; import ast.enums.CompoundValueRepresentation; @@ -23,6 +24,7 @@ import util.exception.SMTUnimplementedException; import util.types.ASTRepresentable; import visitor.ifaces.ExpressionVisitorIface; +import visitor.ifaces.expr.VirtualVisitorIface; import visitor.ifaces.symbolic.SelectVisitorIface; import visitor.ifaces.symbolic.StoreVisitorIface; import visitor.ifaces.symbolic.ValidSelectVisitorIface; @@ -33,7 +35,8 @@ public class SMTVisitor StoreVisitorIface, SelectVisitorIface, ValidStoreVisitorIface, - ValidSelectVisitorIface + ValidSelectVisitorIface, + VirtualVisitorIface { private final AlkSMTContext alkCtx; @@ -463,4 +466,16 @@ public Expr visit(ResultAST ctx) { throw new SMTUnimplementedException(ResultAST.class); } + + @Override + public Expr visit(MapAST ctx) + { + throw new SMTUnimplementedException(ResultAST.class); + } + + @Override + public Expr visit(VirtualAST ctx) + { + throw new SMTUnimplementedException(VirtualAST.class); + } } diff --git a/src/main/java/symbolic/ASTCloner.java b/src/main/java/symbolic/ASTCloner.java index da089ceb..cc15b367 100644 --- a/src/main/java/symbolic/ASTCloner.java +++ b/src/main/java/symbolic/ASTCloner.java @@ -17,6 +17,7 @@ import util.lambda.LocationGenerator; import visitor.ifaces.ExpressionVisitorIface; import visitor.ifaces.expr.DataTypeVisitorIface; +import visitor.ifaces.expr.VirtualVisitorIface; import visitor.ifaces.stmt.IdDeclVisitorIface; import visitor.ifaces.symbolic.*; @@ -28,7 +29,8 @@ public class ASTCloner ValidSelectVisitorIface, ValidStoreVisitorIface, IdDeclVisitorIface, - DataTypeVisitorIface + DataTypeVisitorIface, + VirtualVisitorIface { private LocationMapperIface mapper; private LocationGenerator generator; @@ -327,4 +329,16 @@ public AST visit(ResultAST tree) { return tree; } + + @Override + public AST visit(MapAST tree) + { + return tree; + } + + @Override + public AST visit(VirtualAST tree) + { + return tree; + } } diff --git a/src/main/java/util/pc/PathCondition.java b/src/main/java/util/pc/PathCondition.java index 8d63a320..275b9213 100644 --- a/src/main/java/util/pc/PathCondition.java +++ b/src/main/java/util/pc/PathCondition.java @@ -62,8 +62,17 @@ public PathCondition(PathCondition copy, LocationMapper mapper) public boolean add(SymbolicValue symbolicValue) + { + return add(symbolicValue, true); + } + + public boolean add(SymbolicValue symbolicValue, boolean verify) { conditions.add(symbolicValue); + if (!verify) + { + return true; + } return alkCtx.process(symbolicValue); } diff --git a/src/main/java/visitor/SmallStepExpressionVisitor.java b/src/main/java/visitor/SmallStepExpressionVisitor.java index 0e281329..fb27a959 100644 --- a/src/main/java/visitor/SmallStepExpressionVisitor.java +++ b/src/main/java/visitor/SmallStepExpressionVisitor.java @@ -317,6 +317,12 @@ public T visit(ResultAST ctx) throw new InternalException("To be implemented!"); } + @Override + public T visit(MapAST ctx) + { + throw new InternalException("To be implemented!"); + } + static class DataStructureVisitor { SmallStepExpressionVisitor exprVisitor; diff --git a/src/main/java/visitor/ifaces/ExpressionVisitorIface.java b/src/main/java/visitor/ifaces/ExpressionVisitorIface.java index 592b91e9..fb46a4a9 100644 --- a/src/main/java/visitor/ifaces/ExpressionVisitorIface.java +++ b/src/main/java/visitor/ifaces/ExpressionVisitorIface.java @@ -28,6 +28,7 @@ public interface ExpressionVisitorIface ListVisitorIface, LogicalAndVisitorIface, LogicalOrVisitorIface, + MapVisitorIface, MultiplicativeVisitorIface, PostfixVisitorIface, PrefixVisitorIface, diff --git a/src/main/java/visitor/ifaces/expr/MapVisitorIface.java b/src/main/java/visitor/ifaces/expr/MapVisitorIface.java new file mode 100644 index 00000000..8499664d --- /dev/null +++ b/src/main/java/visitor/ifaces/expr/MapVisitorIface.java @@ -0,0 +1,10 @@ +package visitor.ifaces.expr; + +import ast.expr.MapAST; +import visitor.ifaces.VisitorIface; + +public interface MapVisitorIface +extends VisitorIface +{ + T visit(MapAST ctx); +} diff --git a/src/main/java/visitor/ifaces/expr/VirtualVisitorIface.java b/src/main/java/visitor/ifaces/expr/VirtualVisitorIface.java new file mode 100644 index 00000000..8d82bbc1 --- /dev/null +++ b/src/main/java/visitor/ifaces/expr/VirtualVisitorIface.java @@ -0,0 +1,10 @@ +package visitor.ifaces.expr; + +import ast.VirtualAST; +import visitor.ifaces.VisitorIface; + +public interface VirtualVisitorIface +extends VisitorIface +{ + T visit(VirtualAST ctx); +} diff --git a/src/main/java/visitor/stateful/StatefulExpressionVisitor.java b/src/main/java/visitor/stateful/StatefulExpressionVisitor.java index dba0d720..1b568262 100644 --- a/src/main/java/visitor/stateful/StatefulExpressionVisitor.java +++ b/src/main/java/visitor/stateful/StatefulExpressionVisitor.java @@ -261,4 +261,10 @@ public S visit(ResultAST tree) { return expressionInterpreter.interpretContextVar(ContextVar.RESULT, tree, payload); } + + @Override + public S visit(MapAST tree) + { + return expressionInterpreter.interpretComposite(Primitive.MAP, tree, payload); + } } diff --git a/tests/input/symbolic-algo/fast_exp.alk b/tests/input/symbolic-algo/fast_exp.alk index bd368e7e..349c9790 100644 --- a/tests/input/symbolic-algo/fast_exp.alk +++ b/tests/input/symbolic-algo/fast_exp.alk @@ -17,4 +17,5 @@ assert 0 <= b - 1 result == $f assume b - 1 > 0 ==> $f == a * fast_exp(a, b - 1 - 1) -assume b - 1 == 0 ==> $f == 1 \ No newline at end of file +assume b - 1 == 0 ==> $f == 1 +