diff --git a/.gitignore b/.gitignore index 978d7751..22c6bda0 100644 --- a/.gitignore +++ b/.gitignore @@ -15,7 +15,7 @@ build release .dockerignore - +.DS_Store # IDE files .vscode .idea diff --git a/.gitmodules b/.gitmodules index f479de32..aeea0a4c 100644 --- a/.gitmodules +++ b/.gitmodules @@ -17,3 +17,6 @@ url = https://git.mirror.iscas.ac.cn/ao-space/google-webrtc.git branch = main shallow = true +[submodule "dep/msquic"] + path = dep/msquic + url = https://github.com/microsoft/msquic diff --git a/Dockerfile b/Dockerfile index c6b278aa..9598663e 100644 --- a/Dockerfile +++ b/Dockerfile @@ -30,6 +30,14 @@ RUN apt-get install -y ca-certificates curl gnupg && \ apt-get update && \ apt-get install nodejs -y +# 安装msquic依赖 +RUN apt-get update && \ + apt-get install -y cmake build-essential liblttng-ust-dev lttng-tools libssl-dev && \ + wget https://cmake.org/files/v3.23/cmake-3.23.0.tar.gz && \ + tar -zxvf cmake-3.23.0.tar.gz && cd cmake-3.23.0 && ./configure && make -j8 && make install && \ + cmake --version +# RUN apt-get install -y cmake build-essential liblttng-ust-dev lttng-tools + # golang 切换国内源并且提前安装好依赖 ENV GO111MODULE=on ENV GOPROXY=https://goproxy.cn @@ -51,4 +59,4 @@ RUN if uname -m | grep aarch64; then \ file /usr/x86_64-linux-gnu/lib/libm.a | grep "ASCII text" && \ rm -f /usr/x86_64-linux-gnu/lib/libm.a && \ ln -s /usr/x86_64-linux-gnu/lib/libm-2.31.a /usr/x86_64-linux-gnu/lib/libm.a && echo "success"; \ - fi + fi \ No newline at end of file diff --git a/Makefile b/Makefile index ac852a53..4ef2f8c5 100644 --- a/Makefile +++ b/Makefile @@ -57,11 +57,16 @@ export GOOS?=$(shell go env GOOS) export GOARCH?=$(shell go env GOARCH) export CC=$(TARGET)-gcc -w export CXX=$(TARGET)-g++ -w -export CGO_CXXFLAGS=-I$(shell pwd)/dep/_google-webrtc/src -I$(shell pwd)/dep/_google-webrtc/src/third_party/abseil-cpp -std=c++17 -DWEBRTC_POSIX -export CGO_LDFLAGS=$(shell pwd)/dep/_google-webrtc/src/out/release-$(TARGET)/obj/libwebrtc.a -ldl -pthread +export CGO_CXXFLAGS=-I$(shell pwd)/dep/_google-webrtc/src \ + -I$(shell pwd)/dep/_google-webrtc/src/third_party/abseil-cpp \ + -I$(shell pwd)/dep/msquic/src/inc \ + -std=c++17 -DWEBRTC_POSIX -DQUIC_API_ENABLE_PREVIEW_FEATURES +export CGO_LDFLAGS= $(shell pwd)/dep/_google-webrtc/src/out/release-$(TARGET)/obj/libwebrtc.a \ + $(shell pwd)/dep/msquic/$(TARGET)/bin/Release/libmsquic.a \ + -ldl -pthread export CGO_ENABLED=1 -.PHONY: all build docker_build_linux_arm64 fmt build_client docker_build_linux_arm64_client gofumpt build_server docker_build_linux_arm64_server golangci-lint check_webrtc_dependencies docker_release_linux_amd64 release clean docker_release_linux_amd64_client release_client compile_webrtc docker_release_linux_amd64_server release_server docker_create_image docker_build_linux_amd64 docker_release_linux_arm64 revive docker_build_linux_amd64_client docker_release_linux_arm64_client test docker_build_linux_amd64_server docker_release_linux_arm64_server update_submodule build_web_server build_web_client release_web_server release_web_client check_npm front_release duplicate_dist_server clean_duplication_client clean_web clean_dist clean_duplication clean_duplication_server clean_duplication_client +.PHONY: all build docker_build_linux_arm64 fmt build_client docker_build_linux_arm64_client gofumpt build_server docker_build_linux_arm64_server golangci-lint check_webrtc_dependencies docker_release_linux_amd64 release clean docker_release_linux_amd64_client release_client compile_webrtc docker_release_linux_amd64_server release_server docker_create_image docker_build_linux_amd64 docker_release_linux_arm64 revive docker_build_linux_amd64_client docker_release_linux_arm64_client test docker_build_linux_amd64_server docker_release_linux_arm64_server update_submodule build_web_server build_web_client release_web_server release_web_client check_npm front_release duplicate_dist_server clean_duplication_client clean_web clean_dist clean_duplication clean_duplication_server clean_duplication_client check_msquic_dependencies compile_msquic all: gofumpt golangci-lint test release @@ -71,9 +76,9 @@ gofumpt: gofumpt --version || go install mvdan.cc/gofumpt@latest gofumpt -l -w $(shell find . -name '*.go' | grep -Ev '^\./bufio|^\./client/std|^\./logger/file-rotatelogs|^\./dep') -test: compile_webrtc +test: compile_webrtc compile_msquic $(eval CGO_CXXFLAGS+=-O0 -g -ggdb) - go test -race -cover -count 1 ./... + go test -race -cover -count 1 ./bufio ./client ./config ./server ./test ./util golangci-lint: golangci-lint --version || go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest @@ -90,6 +95,24 @@ golangci-lint: update_submodule: git config --global --add safe.directory /go/src/github.com/isrc-cas/gt git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/_google-webrtc + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/clog + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/googletest + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl/boringssl + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3 + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/gost-engine + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl/krb5 + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/gost-engine/libprov + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl/pyca-cryptography + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/krb5 + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl/wycheproof + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/oqs-provider + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/pyca-cryptography + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/python-ecdsa + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/tlsfuzzer + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/tlslite-ng + git config --global --add safe.directory /go/src/github.com/isrc-cas/gt/dep/msquic/submodules/openssl3/wycheproof $(UPDATE_SUBMODULE_COMMAND) docker_create_image: update_submodule @@ -127,19 +150,19 @@ docker_release_linux_arm64_server: docker_create_image build: build_server build_client release: release_server release_client -build_client: $(SOURCES) Makefile compile_webrtc build_web_client +build_client: $(SOURCES) Makefile compile_msquic compile_webrtc build_web_client $(eval CGO_CXXFLAGS+=-O0 -g -ggdb) $(eval NAME=$(GOOS)-$(GOARCH)-client) go build $(DEBUG_OPTIONS) -o build/$(NAME)$(EXE) ./cmd/client -release_client: $(SOURCES) Makefile compile_webrtc release_web_client +release_client: $(SOURCES) Makefile compile_msquic compile_webrtc release_web_client $(eval CGO_CXXFLAGS+=-O3) $(eval NAME=$(GOOS)-$(GOARCH)-client) go build $(RELEASE_OPTIONS) -o release/$(NAME)$(EXE) ./cmd/client -build_server: $(SOURCES) Makefile compile_webrtc build_web_server +build_server: $(SOURCES) Makefile compile_msquic compile_webrtc build_web_server $(eval CGO_CXXFLAGS+=-O0 -g -ggdb) $(eval NAME=$(GOOS)-$(GOARCH)-server) go build $(DEBUG_OPTIONS) -o build/$(NAME)$(EXE) ./cmd/server -release_server: $(SOURCES) Makefile compile_webrtc release_web_server +release_server: $(SOURCES) Makefile compile_msquic compile_webrtc release_web_server $(eval CGO_CXXFLAGS+=-O3) $(eval NAME=$(GOOS)-$(GOARCH)-server) go build $(RELEASE_OPTIONS) -o release/$(NAME)$(EXE) ./cmd/server @@ -224,3 +247,20 @@ compile_webrtc: check_webrtc_dependencies update_submodule sed -i 's| [^ ]*g++ | $(CXX) |g' ./dep/_google-webrtc/src/out/release-$(TARGET)/toolchain.ninja sed -i 's|"ar"|$(TARGET)-ar|g' ./dep/_google-webrtc/src/out/release-$(TARGET)/toolchain.ninja ninja -C ./dep/_google-webrtc/src/out/release-$(TARGET) + +check_msquic_dependencies: + sh -c "command -v cmake" + +compile_msquic: check_msquic_dependencies update_submodule + mkdir -p ./dep/msquic/$(TARGET) + sed -i 's|\(^ *msquic_lib\)$$|\1 ALL|g' ./dep/msquic/src/bin/CMakeLists.txt + cmake -B./dep/msquic/$(TARGET) -S./dep/msquic -DQUIC_BUILD_SHARED=OFF -DCMAKE_TARGET_ARCHITECTURE=$(TARGET_CPU) +ifeq ($(TARGET_CPU),arm64) + make -C./dep/msquic/$(TARGET) -j$(shell nproc) + @renameSymbols=$$(objdump -t ./dep/msquic/$(TARGET)/bin/Release/libmsquic.a | awk -v RS= '/_YB80VJ/{next}1' | grep -E 'g +(F|O) ' | grep -Evi ' (ms){0,1}quic' | awk '{print " --redefine-sym " $$NF "=" $$NF "_YB80VJ"}') && \ + aarch64-linux-gnu-objcopy $$renameSymbols ./dep/msquic/$(TARGET)/bin/Release/libmsquic.a +else + make -C./dep/msquic/$(TARGET) -j$(shell nproc) + @renameSymbols=$$(objdump -t ./dep/msquic/$(TARGET)/bin/Release/libmsquic.a | awk -v RS= '/_YB80VJ/{next}1' | grep -E 'g +(F|O) ' | grep -Evi ' (ms){0,1}quic' | awk '{print " --redefine-sym " $$NF "=" $$NF "_YB80VJ"}') && \ + objcopy $$renameSymbols ./dep/msquic/$(TARGET)/bin/Release/libmsquic.a +endif \ No newline at end of file diff --git a/README.md b/README.md index 487cfbe3..77992aa9 100644 --- a/README.md +++ b/README.md @@ -33,52 +33,63 @@ Currently implemented main functions: ## Index - -* [Working Principle](#working-principle) -* [Usage](#usage) - * [Configuration File](#configuration-file) - * [Server User Configuration](#server-user-configuration) - * [Configure Users via Command Line](#configure-users-via-command-line) - * [Configure Users via Users Configuration File](#configure-users-via-users-configuration-file) - * [Configure Users via Config Configuration File](#configure-users-via-config-configuration-file) - * [Allow All Clients](#allow-all-clients) - * [Server TCP Configuration](#server-tcp-configuration) - * [Configure TCP via Users Configuration File](#configure-tcp-via-users-configuration-file) - * [Configure TCP via Config Configuration File](#configure-tcp-via-config-configuration-file) - * [Command Line Parameters](#command-line-parameters) - * [Internal HTTP Penetration](#internal-http-penetration) - * [Internal HTTPS Penetration](#internal-https-penetration) - * [Internal HTTPS SNI Penetration](#internal-https-sni-penetration) - * [Encrypt Client-Server Communication with TLS](#encrypt-client-server-communication-with-tls) - * [Internal TCP Penetration](#internal-tcp-penetration) - * [Client Start Multiple Services Simultaneously](#client-start-multiple-services-simultaneously) - * [Server API](#server-api) -* [Performance Test](#performance-test) - * [GT benchmark](#gt-benchmark) - * [frp dev branch 42745a3](#frp-dev-branch-42745a3) -* [Run](#run) - * [Docker Container Run](#docker-container-run) -* [Compilation](#compilation) - * [Compilation on Ubuntu/Debian](#compilation-on-ubuntudebian) - * [Install Dependencies](#install-dependencies) - * [Get Code and Compile](#get-code-and-compile) - * [Obtain WebRTC from ISCAS Mirror and Compile GT](#obtain-webrtc-from-iscas-mirror-and-compile-gt) - * [Obtain WebRTC from Official and Compile GT](#obtain-webrtc-from-official-and-compile-gt) - * [Compile on Ubuntu/Debian via Docker](#compile-on-ubuntudebian-via-docker) - * [Install Dependencies](#install-dependencies-1) - * [Get Code and Compile](#get-code-and-compile-1) - * [Obtain WebRTC from ISCAS Mirror and Compile GT](#obtain-webrtc-from-iscas-mirror-and-compile-gt-1) - * [Obtain WebRTC from Official and Compile GT](#obtain-webrtc-from-official-and-compile-gt-1) -* [Roadmap](#roadmap) -* [Contribution Guide](#contribution-guide) - * [Contribute Code](#contribute-code) - * [Code Quality](#code-quality) - * [Commit Messages](#commit-messages) - * [Issue Reporting](#issue-reporting) - * [Feature Requests](#feature-requests) - * [Thank You for Your Contribution](#thank-you-for-your-contribution) - * [Contributors](#contributors) - +* [GT](#gt) + * [Index](#index) + * [Working Principle](#working-principle) + * [Usage](#usage) + * [Configuration File](#configuration-file) + * [Server User Configuration](#server-user-configuration) + * [Configure Users via Command Line](#configure-users-via-command-line) + * [Configure Users via Users Configuration File](#configure-users-via-users-configuration-file) + * [Configure Users via Config Configuration File](#configure-users-via-config-configuration-file) + * [Allow All Clients](#allow-all-clients) + * [Server TCP Configuration](#server-tcp-configuration) + * [Configure TCP via Users Configuration File](#configure-tcp-via-users-configuration-file) + * [Configure TCP via Config Configuration File](#configure-tcp-via-config-configuration-file) + * [Command Line Parameters](#command-line-parameters) + * [Internal HTTP Penetration](#internal-http-penetration) + * [Internal HTTPS Penetration](#internal-https-penetration) + * [Internal HTTPS SNI Penetration](#internal-https-sni-penetration) + * [Encrypt Client-Server Communication with TLS](#encrypt-client-server-communication-with-tls) + * [Internal TCP Penetration](#internal-tcp-penetration) + * [Internal QUIC Penetration](#internal-quic-penetration) + * [Intelligent Internal Penetration (Adaptive Selection of TCP/QUIC)](#intelligent-internal-penetration-adaptive-selection-of-tcpquic) + * [Client Start Multiple Services Simultaneously](#client-start-multiple-services-simultaneously) + * [Server API](#server-api) + * [Performance Test](#performance-test) + * [Group 1 (MacOS environment+nginx testing)](#group-1-macos-environmentnginx-testing) + * [GT benchmark](#gt-benchmark) + * [frp dev branch 42745a3](#frp-dev-branch-42745a3) + * [Group 2 (Ubuntu environment+nginx testing)](#group-2-ubuntu-environmentnginx-testing) + * [GT-TCP](#gt-tcp) + * [GT-QUIC](#gt-quic) + * [frp v0.52.1](#frp-v0521) + * [Group 3 (Ubuntu environment+short request testing)](#group-3-ubuntu-environmentshort-request-testing) + * [GT-TCP](#gt-tcp-1) + * [GT-QUIC](#gt-quic-1) + * [frp v0.52.1](#frp-v0521-1) + * [Run](#run) + * [Docker Container Run](#docker-container-run) + * [Compilation](#compilation) + * [Compilation on Ubuntu/Debian](#compilation-on-ubuntudebian) + * [Install Dependencies](#install-dependencies) + * [Get Code and Compile](#get-code-and-compile) + * [Obtain WebRTC from ISCAS Mirror and Compile GT](#obtain-webrtc-from-iscas-mirror-and-compile-gt) + * [Obtain WebRTC from Official and Compile GT](#obtain-webrtc-from-official-and-compile-gt) + * [Compile on Ubuntu/Debian via Docker](#compile-on-ubuntudebian-via-docker) + * [Install Dependencies](#install-dependencies-1) + * [Get Code and Compile](#get-code-and-compile-1) + * [Obtain WebRTC from ISCAS Mirror and Compile GT](#obtain-webrtc-from-iscas-mirror-and-compile-gt-1) + * [Obtain WebRTC from Official and Compile GT](#obtain-webrtc-from-official-and-compile-gt-1) + * [Roadmap](#roadmap) + * [Contribution Guide](#contribution-guide) + * [Contribute Code](#contribute-code) + * [Code Quality](#code-quality) + * [Commit Messages](#commit-messages) + * [Issue Reporting](#issue-reporting) + * [Feature Requests](#feature-requests) + * [Thank You for Your Contribution](#thank-you-for-your-contribution) + * [Contributors](#contributors) ## Working Principle @@ -326,6 +337,43 @@ options: ./release/linux-amd64-client -local tcp://127.0.0.1:22 -remote tcp://id1.example.com:8080 -id id1 -secret secret1 -remoteTCPPort 2222 -remoteTCPRandom ``` +#### Internal QUIC Penetration + +- Requirements: There is an intranet server and a public network server, and id1.example.com resolves to the address of the public network server. Hopefully by accessing id1.example.com:8080 + To access the web page served by port 80 on the intranet server. Use QUIC to build a transport connection between the client and the server. QUIC uses TLS 1.3 for transport encryption. When the user also gives certFile + and keyFile, use them for encrypted communication. Otherwise, keys and certificates are automatically generated using the ECDSA encryption algorithm. + +- Server (public network server) + +```shell +./release/linux-amd64-server -addr 8080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +``` + +- Client (internal network server), because a self-signed certificate is used, the `-remoteCertInsecure` option is used. This option is prohibited from being used in other cases (man-in-the-middle attacks cause encrypted content to be decrypted + +```shell +./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remoteCertInsecure -id id1 -secret secret1 +``` + +#### Intelligent Internal Penetration (Adaptive Selection of TCP/QUIC) + +- - Requirements: There is an intranet server and a public network server, and id1.example.com resolves to the address of the public network server. Hopefully by accessing id1.example.com:8080 + To access the web page served by port 80 on the intranet server. GT server listens to multiple addresses. GT client provides multiple `-remote` options and currently supports intelligent switching between QUIC and TCP/TLS. + GT client concurrently sends multiple sets of network status detection probes through QUIC connections to obtain the network delay and packet loss rate between the intranet server and the public network server. + Input the trained XGBoost model to obtain the results, and adaptively select whether to use TCP+TLS or QUIC for intranet penetration. + +- Server (public network server) + +```shell +./release/linux-amd64-server -addr 8080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +``` + +- Client (intranet server). `-remote` requires at least one QUIC address to be given. + +```shell +./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remote tcp://id1.example.com:8080 -remoteCertInsecure -id id1 -secret secret1 +``` + #### Client Start Multiple Services Simultaneously - Requirement: There is an internal network server and a public network server, and id1-1.example.com and @@ -402,18 +450,20 @@ and apiKeyFile options are not empty, otherwise HTTP is used. ## Performance Test +### Group 1 (MacOS environment+nginx testing) + Load testing was performed on this project and frp for comparison using wrk. The internal service points to a test page running nginx locally, and the test results are as follows: ```text -Model Name: MacBook Pro +Model Name: MacBook Pro Model Identifier: MacBookPro17,1 Chip: Apple M1 Total Number of Cores: 8 (4 performance and 4 efficiency) Memory: 16 GB ``` -### GT benchmark +#### GT benchmark ```shell $ wrk -c 100 -d 30s -t 10 http://pi.example.com:7001 @@ -432,7 +482,7 @@ $ ps aux 2767 0.0 0.1 408703664 17584 s007 S+ 4:55PM 0:52.16 ./server -port 7001 ``` -### frp dev branch 42745a3 +#### frp dev branch 42745a3 ```shell $ wrk -c 100 -d 30s -t 10 http://pi.example.com:7000 @@ -452,6 +502,125 @@ $ ps aux 2976 0.0 0.4 408712832 66112 s005 S+ 5:01PM 1:06.51 ./frpc -c ./frpc.ini ``` +### Group 2 (Ubuntu environment+nginx testing) + +Load testing was performed on this project and frp for comparison using wrk. The internal service points to a test page +running nginx locally, and the test results are as follows: + +```text +System: Ubuntu 22.04 +Chip: Intel i9-12900 +Total Number of Cores: 16 (8 performance and 8 efficiency) +Memory: 32 GB +``` + +#### GT-TCP + +```shell +$ ./release/linux-amd64-server -addr 12080 -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote tcp://id1.example.com:12080 -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080 +Running 30s test @ http://id1.example.com:12080 + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 558.51us 2.05ms 71.54ms 99.03% + Req/Sec 24.29k 2.28k 49.07k 95.74% + 7264421 requests in 30.10s, 5.81GB read +Requests/sec: 241344.46 +Transfer/sec: 197.70MB +``` + +#### GT-QUIC + +```shell +$ ./release/linux-amd64-server -addr 12080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remoteCertInsecure -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080 +Running 30s test @ http://id1.example.com:12080 + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 826.65us 1.14ms 66.29ms 98.68% + Req/Sec 12.91k 1.36k 23.53k 79.43% + 3864241 requests in 30.10s, 3.09GB read +Requests/sec: 128380.49 +Transfer/sec: 105.16MB +``` + +#### frp v0.52.1 + +```shell +$ ./frps -c ./frps.toml +$ ./frpc -c ./frpc.toml + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 4.49ms 8.27ms 154.62ms 92.43% + Req/Sec 4.02k 2.08k 7.51k 53.21% + 1203236 requests in 30.08s, 0.93GB read +Requests/sec: 40003.03 +Transfer/sec: 31.82MB +``` + +### Group 3 (Ubuntu environment+short request testing) + +By using wrk for stress testing, this project is compared with frp. Each request only returns a field response of less +than 10 bytes, which is used to simulate HTTP short requests. The test results are as follows: + +#### GT-TCP + +```shell +$ ./release/linux-amd64-server -addr 12080 -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote tcp://id1.example.com:12080 -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 4.55ms 13.48ms 220.23ms 95.31% + Req/Sec 5.23k 2.11k 12.40k 76.10% + 1557980 requests in 30.06s, 191.67MB read +Requests/sec: 51822.69 +Transfer/sec: 6.38MB +``` + +#### GT-QUIC + +```shell +$ ./release/linux-amd64-server -addr 12080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remoteCertInsecure -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 1.84ms 6.75ms 168.93ms 98.47% + Req/Sec 9.33k 2.13k 22.86k 78.54% + 2787908 requests in 30.10s, 342.98MB read +Requests/sec: 92622.63 +Transfer/sec: 11.39MB +``` + +#### frp v0.52.1 + +```shell +$ ./frps -c ./frps.toml +$ ./frpc -c ./frpc.toml + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 2.95ms 3.74ms 136.09ms 91.10% + Req/Sec 4.16k 1.22k 12.86k 87.85% + 1243103 requests in 30.07s, 152.93MB read +Requests/sec: 41334.52 +Transfer/sec: 5.09MB +``` + ## Run ### Docker Container Run diff --git a/README_CN.md b/README_CN.md index b9784991..69cd2dec 100644 --- a/README_CN.md +++ b/README_CN.md @@ -37,53 +37,64 @@ GT 是一个支持点对点直连（P2P）和互联网中转的反向代理开 ## 目录 - -* [工作原理](#工作原理) -* [用法](#用法) - * [Web 管理](#web-管理) - * [配置文件](#配置文件) - * [服务端配置 users](#服务端配置-users) - * [通过命令行配置 users](#通过命令行配置-users) - * [通过 users 配置文件配置 users](#通过-users-配置文件配置-users) - * [通过 config 配置文件配置 users](#通过-config-配置文件配置-users) - * [允许所有的客户端](#允许所有的客户端) - * [服务端配置 TCP](#服务端配置-tcp) - * [通过 users 配置文件配置 TCP](#通过-users-配置文件配置-tcp) - * [通过 config 配置文件配置 TCP](#通过-config-配置文件配置-tcp) - * [命令行参数](#命令行参数) - * [HTTP 内网穿透](#http-内网穿透) - * [HTTPS 内网穿透](#https-内网穿透) - * [HTTPS SNI 内网穿透](#https-sni-内网穿透) - * [TLS 加密客户端服务端之间的通信](#tls-加密客户端服务端之间的通信) - * [TCP 内网穿透](#tcp-内网穿透) - * [客户端同时开启多个服务](#客户端同时开启多个服务) - * [服务端 API](#服务端-api) -* [性能测试](#性能测试) - * [GT benchmark](#gt-benchmark) - * [frp dev branch 42745a3](#frp-dev-branch-42745a3) -* [运行](#运行) - * [Docker 容器运行](#docker-容器运行) -* [编译](#编译) - * [在 Ubuntu/Debian 上编译](#在-ubuntudebian-上编译) - * [安装依赖](#安装依赖) - * [获取代码并编译](#获取代码并编译) - * [从 ISCAS 镜像获取 WebRTC 并编译 GT](#从-iscas-镜像获取-webrtc-并编译-gt) - * [从官方获取 WebRTC 并编译 GT](#从官方获取-webrtc-并编译-gt) - * [在 Ubuntu/Debian 上通过 Docker 编译](#在-ubuntudebian-上通过-docker-编译) - * [安装依赖](#安装依赖-1) - * [获取代码并编译](#获取代码并编译-1) - * [从 ISCAS 镜像获取 WebRTC 并编译 GT](#从-iscas-镜像获取-webrtc-并编译-gt-1) - * [从官方获取 WebRTC 并编译 GT](#从官方获取-webrtc-并编译-gt-1) -* [演进计划](#演进计划) -* [贡献指南](#贡献指南) - * [贡献代码](#贡献代码) - * [代码质量](#代码质量) - * [提交信息](#提交信息) - * [问题报告](#问题报告) - * [功能请求](#功能请求) - * [感谢您的贡献](#感谢您的贡献) - * [贡献者](#贡献者) - +- [GT](#gt) + - [目录](#目录) + - [工作原理](#工作原理) + - [用法](#用法) + - [Web 管理](#web-管理) + - [配置文件](#配置文件) + - [服务端配置 users](#服务端配置-users) + - [通过命令行配置 users](#通过命令行配置-users) + - [通过 users 配置文件配置 users](#通过-users-配置文件配置-users) + - [通过 config 配置文件配置 users](#通过-config-配置文件配置-users) + - [允许所有的客户端](#允许所有的客户端) + - [服务端配置 TCP](#服务端配置-tcp) + - [通过 users 配置文件配置 TCP](#通过-users-配置文件配置-tcp) + - [通过 config 配置文件配置 TCP](#通过-config-配置文件配置-tcp) + - [命令行参数](#命令行参数) + - [HTTP 内网穿透](#http-内网穿透) + - [HTTPS 内网穿透](#https-内网穿透) + - [HTTPS SNI 内网穿透](#https-sni-内网穿透) + - [TLS 加密客户端服务端之间的通信](#tls-加密客户端服务端之间的通信) + - [TCP 内网穿透](#tcp-内网穿透) + - [QUIC 内网穿透](#quic-内网穿透) + - [智能内网穿透（自适应选择 TCP/QUIC ）](#智能内网穿透自适应选择-tcpquic-) + - [客户端同时开启多个服务](#客户端同时开启多个服务) + - [服务端 API](#服务端-api) + - [性能测试](#性能测试) + - [第一组（MacOS环境+nginx测试）](#第一组macos环境nginx测试) + - [GT benchmark](#gt-benchmark) + - [frp dev branch 42745a3](#frp-dev-branch-42745a3) + - [第二组（Ubuntu环境+nginx测试）](#第二组ubuntu环境nginx测试) + - [GT-TCP](#gt-tcp) + - [GT-QUIC](#gt-quic) + - [frp v0.52.1](#frp-v0521) + - [第三组(Ubuntu环境+short request测试)](#第三组ubuntu环境short-request测试) + - [GT-TCP](#gt-tcp-1) + - [GT-QUIC](#gt-quic-1) + - [frp v0.52.1](#frp-v0521-1) + - [运行](#运行) + - [Docker 容器运行](#docker-容器运行) + - [编译](#编译) + - [在 Ubuntu/Debian 上编译](#在-ubuntudebian-上编译) + - [安装依赖](#安装依赖) + - [获取代码并编译](#获取代码并编译) + - [从 ISCAS 镜像获取 WebRTC 并编译 GT](#从-iscas-镜像获取-webrtc-并编译-gt) + - [从官方获取 WebRTC 并编译 GT](#从官方获取-webrtc-并编译-gt) + - [在 Ubuntu/Debian 上通过 Docker 编译](#在-ubuntudebian-上通过-docker-编译) + - [安装依赖](#安装依赖-1) + - [获取代码并编译](#获取代码并编译-1) + - [从 ISCAS 镜像获取 WebRTC 并编译 GT](#从-iscas-镜像获取-webrtc-并编译-gt-1) + - [从官方获取 WebRTC 并编译 GT](#从官方获取-webrtc-并编译-gt-1) + - [演进计划](#演进计划) + - [贡献指南](#贡献指南) + - [贡献代码](#贡献代码) + - [代码质量](#代码质量) + - [提交信息](#提交信息) + - [问题报告](#问题报告) + - [功能请求](#功能请求) + - [感谢您的贡献](#感谢您的贡献) + - [贡献者](#贡献者) ## 工作原理 @@ -331,6 +342,44 @@ options: ./release/linux-amd64-client -local tcp://127.0.0.1:22 -remote tcp://id1.example.com:8080 -id id1 -secret secret1 -remoteTCPPort 2222 -remoteTCPRandom ``` +#### QUIC 内网穿透 + +- 需求：有一台内网服务器和一台公网服务器，id1.example.com 解析到公网服务器的地址。希望通过访问 id1.example.com:8080 + 来访问内网服务器上 80 端口服务的网页。使用 QUIC 为客户端与服务端之间构建传输连接，QUIC 使用 TLS 1.3 进行传输加密。当用户同时给出certFile + 和keyFile时，使用他们进行加密通信。否则，会使用 ECDSA 加密算法自动生成密钥和证书。默认的拥塞控制算法为 Cubic 算法， 当客户端和用户端同时 + 使用 `-bbr` 选项时，使用 bbr 作为拥塞控制算法。 + +- 服务端（公网服务器） + +```shell +./release/linux-amd64-server -addr 8080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +``` + +- 客户端（内网服务器），因为使用了自签名证书，所以使用了 `-remoteCertInsecure` 选项，其它情况禁止使用此选项（中间人攻击导致加密内容被解密）。 + +```shell +./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remoteCertInsecure -id id1 -secret secret1 +``` + +#### 智能内网穿透（自适应选择 TCP/QUIC ） + +- 需求：有一台内网服务器和一台公网服务器，id1.example.com 解析到公网服务器的地址。希望通过访问 id1.example.com:8080 + 来访问内网服务器上 80 端口服务的网页。GT server监听多个地址，GT client给出了多个 `-remote` 选项，目前支持在 QUIC 和 TCP/TLS 之间进行智能切换。 + GT client 通过 QUIC 连接并发发送多组网络状况探测探针，获取内网服务器和公网服务器之间网络的时延和丢包率， + 输入训练好的XGBoost模型获取结果，自适应选择使用 TCP+TLS 还是 QUIC 进行内网穿透。 + +- 服务端（公网服务器） + +```shell +./release/linux-amd64-server -addr 8080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +``` + +- 客户端（内网服务器）。`-remote` 需要给出至少一个 QUIC 的地址。 + +```shell +./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remote tcp://id1.example.com:8080 -remoteCertInsecure -id id1 -secret secret1 +``` + #### 客户端同时开启多个服务 - 需求：有一台内网服务器和一台公网服务器，id1-1.example.com 和 id1-2.example.com 解析到公网服务器的地址。希望通过访问 @@ -402,6 +451,8 @@ apiCertFile 和 apiKeyFile 选项不为空时使用 HTTPS，其他情况使用 H ## 性能测试 +### 第一组（MacOS环境+nginx测试） + 通过 wrk 进行压力测试本项目与 frp 进行对比，内网服务指向在本地运行 nginx 的测试页面，测试结果如下： ```text @@ -412,7 +463,7 @@ Total Number of Cores: 8 (4 performance and 4 efficiency) Memory: 16 GB ``` -### GT benchmark +#### GT benchmark ```shell $ wrk -c 100 -d 30s -t 10 http://pi.example.com:7001 @@ -431,7 +482,7 @@ $ ps aux 2767 0.0 0.1 408703664 17584 s007 S+ 4:55PM 0:52.16 ./server -port 7001 ``` -### frp dev branch 42745a3 +#### frp dev branch 42745a3 ```shell $ wrk -c 100 -d 30s -t 10 http://pi.example.com:7000 @@ -451,6 +502,123 @@ $ ps aux 2976 0.0 0.4 408712832 66112 s005 S+ 5:01PM 1:06.51 ./frpc -c ./frpc.ini ``` +### 第二组（Ubuntu环境+nginx测试） + +通过 wrk 进行压力测试本项目与 frp 进行对比，内网服务指向在本地运行 nginx 的测试页面，测试结果如下： + +```text +System: Ubuntu 22.04 +Chip: Intel i9-12900 +Total Number of Cores: 16 (8 performance and 8 efficiency) +Memory: 32 GB +``` + +#### GT-TCP + +```shell +$ ./release/linux-amd64-server -addr 12080 -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote tcp://id1.example.com:12080 -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080 +Running 30s test @ http://id1.example.com:12080 + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 558.51us 2.05ms 71.54ms 99.03% + Req/Sec 24.29k 2.28k 49.07k 95.74% + 7264421 requests in 30.10s, 5.81GB read +Requests/sec: 241344.46 +Transfer/sec: 197.70MB +``` + +#### GT-QUIC + +```shell +$ ./release/linux-amd64-server -addr 12080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remoteCertInsecure -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080 +Running 30s test @ http://id1.example.com:12080 + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 826.65us 1.14ms 66.29ms 98.68% + Req/Sec 12.91k 1.36k 23.53k 79.43% + 3864241 requests in 30.10s, 3.09GB read +Requests/sec: 128380.49 +Transfer/sec: 105.16MB +``` + +#### frp v0.52.1 + +```shell +$ ./frps -c ./frps.toml +$ ./frpc -c ./frpc.toml + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 4.49ms 8.27ms 154.62ms 92.43% + Req/Sec 4.02k 2.08k 7.51k 53.21% + 1203236 requests in 30.08s, 0.93GB read +Requests/sec: 40003.03 +Transfer/sec: 31.82MB +``` + +### 第三组(Ubuntu环境+short request测试) + +通过 wrk 进行压力测试本项目与 frp 进行对比，每次请求只会返回小于10字节的字段回复，用于模拟HTTP short request，测试结果如下： + +#### GT-TCP + +```shell +$ ./release/linux-amd64-server -addr 12080 -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote tcp://id1.example.com:12080 -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 4.55ms 13.48ms 220.23ms 95.31% + Req/Sec 5.23k 2.11k 12.40k 76.10% + 1557980 requests in 30.06s, 191.67MB read +Requests/sec: 51822.69 +Transfer/sec: 6.38MB +``` + +#### GT-QUIC + +```shell +$ ./release/linux-amd64-server -addr 12080 -quicAddr 443 -certFile /root/openssl_crt/tls.crt -keyFile /root/openssl_crt/tls.key -id id1 -secret secret1 +$ ./release/linux-amd64-client -local http://127.0.0.1:80 -remote quic://id1.example.com:443 -remoteCertInsecure -id id1 -secret secret1 + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 1.84ms 6.75ms 168.93ms 98.47% + Req/Sec 9.33k 2.13k 22.86k 78.54% + 2787908 requests in 30.10s, 342.98MB read +Requests/sec: 92622.63 +Transfer/sec: 11.39MB +``` + +#### frp v0.52.1 + +```shell +$ ./frps -c ./frps.toml +$ ./frpc -c ./frpc.toml + +$ wrk -c 100 -d 30s -t 10 http://id1.example.com:12080/ +Running 30s test @ http://id1.example.com:12080/ + 10 threads and 100 connections + Thread Stats Avg Stdev Max +/- Stdev + Latency 2.95ms 3.74ms 136.09ms 91.10% + Req/Sec 4.16k 1.22k 12.86k 87.85% + 1243103 requests in 30.07s, 152.93MB read +Requests/sec: 41334.52 +Transfer/sec: 5.09MB +``` + ## 运行 ### Docker 容器运行 diff --git a/client/client.go b/client/client.go index b3b3b6c8..28de27a8 100644 --- a/client/client.go +++ b/client/client.go @@ -22,6 +22,7 @@ import ( "encoding/json" "errors" "fmt" + "github.com/isrc-cas/gt/conn/msquic" "io" "net" "net/http" @@ -238,6 +239,38 @@ func (d *dialer) init(c *Client, remote string, stun string) (err error) { } d.host = u.Host d.dialFn = d.dial + case "quic": + if len(u.Port()) < 1 { + u.Host = net.JoinHostPort(u.Host, "443") + } + tlsConfig := &tls.Config{} + if len(c.Config().RemoteCert) > 0 { + var cf []byte + cf, err = os.ReadFile(c.Config().RemoteCert) + if err != nil { + err = fmt.Errorf("failed to read remote cert file (-remoteCert option) '%s', cause %s", c.Config().RemoteCert, err.Error()) + return + } + roots := x509.NewCertPool() + ok := roots.AppendCertsFromPEM(cf) + if !ok { + err = fmt.Errorf("failed to parse remote cert file (-remoteCert option) '%s'", c.Config().RemoteCert) + return + } + tlsConfig.RootCAs = roots + } + if c.Config().RemoteCertInsecure { + tlsConfig.InsecureSkipVerify = true + } + d.host = u.Host + d.tlsConfig = tlsConfig + //quic-go只有Cubic一种拥塞控制算法 + //msquic默认使用bbr作为拥塞控制算法 + if c.Config().OpenBBR { + d.dialFn = d.msquicDial + } else { + d.dialFn = d.quicDial + } default: err = fmt.Errorf("remote url (-remote option) '%s' is invalid", remote) } @@ -245,7 +278,7 @@ func (d *dialer) init(c *Client, remote string, stun string) (err error) { } func (d *dialer) initWithRemote(c *Client) (err error) { - return d.init(c, c.Config().Remote, c.Config().RemoteSTUN) + return d.init(c, c.Config().Remote[c.chosenRemoteLabel], c.Config().RemoteSTUN) } func (d *dialer) initWithRemoteAPI(c *Client) (err error) { @@ -295,6 +328,14 @@ func (d *dialer) tlsDial() (conn net.Conn, err error) { return tls.Dial("tcp", d.host, d.tlsConfig) } +func (d *dialer) quicDial() (conn net.Conn, err error) { + return connection.QuicDial(d.host, d.tlsConfig) +} + +func (d *dialer) msquicDial() (conn net.Conn, err error) { + return msquic.MsquicDial(d.host, d.tlsConfig) +} + // Start runs the client agent. func (c *Client) Start() (err error) { c.Logger.Info().Msg(predef.Version) @@ -343,8 +384,57 @@ func (c *Client) Start() (err error) { var dialer dialer if len(c.Config().Remote) > 0 { - if !strings.Contains(c.Config().Remote, "://") { - c.Config().Remote = "tcp://" + c.Config().Remote + var hasQuic bool + var enterSwitch bool + for index, _ := range c.Config().Remote { + if !strings.Contains(c.Config().Remote[index], "://") { + c.Config().Remote[index] = "tcp://" + c.Config().Remote[index] + } + } + if len(c.Config().Remote) >= 2 { + enterSwitch = true + for index, remote := range c.Config().Remote { + var u *url.URL + u, err = url.Parse(remote) + if err != nil { + err = fmt.Errorf("remote url (-remote option) '%s' is invalid, cause %s", remote, err.Error()) + return + } + if u.Scheme == "quic" { + c.Logger.Info().Str("remote", remote).Msg("waiting...intelligent switch are sending probes to get network conditions...") + hasQuic = true + if len(u.Port()) < 1 { + u.Host = net.JoinHostPort(u.Host, "443") + } + var avgRtt, pktLoss float64 + avgRtt, pktLoss, err = connection.GetQuicProbesResults(u.Host) + if err != nil { + c.Logger.Error().Err(err).Msg("can not use QUIC connection to detect network conditions") + return err + } + + c.Logger.Info().Float64("averageRTT", avgRtt).Float64("lossRate", pktLoss).Msg("QUIC probes get network conditions with") + var networkCondition = []float64{0, 0, 0, 0, avgRtt, pktLoss, 0, 0, 0, 0} + result := connection.PredictWithRttAndLoss(networkCondition) + if result[1] > result[0] { + c.chosenRemoteLabel = index + } else { + if index == 0 { + c.chosenRemoteLabel = 1 + } else { + c.chosenRemoteLabel = 0 + } + } + } + } + if !hasQuic { + c.chosenRemoteLabel = 0 + } + } else { + c.chosenRemoteLabel = 0 + } + if enterSwitch { + c.Logger.Info().Str("remote", c.Config().Remote[c.chosenRemoteLabel]).Msg("intelligent switch strategy finally choose to establish with") } err = dialer.initWithRemote(c) if err != nil { diff --git a/client/config.go b/client/config.go index d826db80..a59dc4ea 100644 --- a/client/config.go +++ b/client/config.go @@ -41,7 +41,7 @@ type Options struct { ID string `yaml:"id,omitempty" json:",omitempty" usage:"The unique id used to connect to server. Now it's the prefix of the domain."` Secret string `yaml:"secret,omitempty" json:",omitempty" usage:"The secret used to verify the id"` ReconnectDelay config.Duration `yaml:"reconnectDelay,omitempty" json:",omitempty" usage:"The delay before reconnect. Supports values like '30s', '5m'"` - Remote string `yaml:"remote,omitempty" json:",omitempty" usage:"The remote server url. Supports tcp:// and tls://, default tcp://"` + Remote config.Slice[string] `yaml:"remote,omitempty" json:",omitempty" usage:"The remote server url. Supports tcp:// and tls:// and quic://, default tcp://"` RemoteSTUN string `yaml:"remoteSTUN,omitempty" json:",omitempty" usage:"The remote STUN server address"` RemoteAPI string `yaml:"remoteAPI,omitempty" json:",omitempty" usage:"The API to get remote server url"` RemoteCert string `yaml:"remoteCert,omitempty" json:",omitempty" usage:"The path to remote cert"` @@ -89,6 +89,9 @@ type Options struct { Password string `arg:"password" yaml:"password,omitempty" json:"-" usage:"Admin password use for login in web server"` Signal string `arg:"s" yaml:"-" json:"-" usage:"Send signal to client processes. Supports values: reload, restart, stop, kill"` + + OpenBBR bool `yaml:"bbr" usage:"Use bbr as congestion control algorithm (through msquic) when GT use QUIC connection. Default algorithm is Cubic (through quic-go)."` + } // if you enable web service, it will set 'Config' if not specified @@ -112,6 +115,8 @@ func defaultConfig() Config { LogFileMaxCount: 7, LogFileMaxSize: 512 * 1024 * 1024, LogLevel: zerolog.InfoLevel.String(), + + OpenBBR: false, }, } } diff --git a/client/debug.go b/client/debug.go index 0b695fc9..f1c2075b 100644 --- a/client/debug.go +++ b/client/debug.go @@ -48,6 +48,9 @@ type Client struct { // test purpose only OnTunnelClose atomic.Value + + // indicate which remote is chosen to establish tunnel + chosenRemoteLabel int } func (c *conn) onTunnelClose() { diff --git a/client/release.go b/client/release.go index 3478d57e..ecc0537a 100644 --- a/client/release.go +++ b/client/release.go @@ -45,6 +45,9 @@ type Client struct { configChecksum atomic.Pointer[[32]byte] reloadWaitGroup sync.WaitGroup reloading atomic.Bool + + // indicate which remote is chosen to establish tunnel + chosenRemoteLabel int } func (c *conn) onTunnelClose() { diff --git a/conn/msquic/conneciton.go b/conn/msquic/conneciton.go new file mode 100644 index 00000000..a77970c9 --- /dev/null +++ b/conn/msquic/conneciton.go @@ -0,0 +1,206 @@ +package msquic + +/* +#include + +#include "connection.h" +#include "stream.h" +*/ +import "C" + +import ( + "errors" + "net" + "strconv" + "sync" + "time" + "unsafe" + + "github.com/mattn/go-pointer" +) + +type Connection struct { + cppConn unsafe.Pointer + pointerID unsafe.Pointer + onConnected chan struct{} + onPeerStreamStarted chan net.Conn + onClose chan struct{} + closeOnce sync.Once +} + +func NewConnection( + server string, + idleTimeoutMs uint64, + certFile string, + unsecure bool, +) (conn *Connection, err error) { + conn = &Connection{ + onConnected: make(chan struct{}, 1), + onPeerStreamStarted: make(chan net.Conn, 1), + onClose: make(chan struct{}), + } + conn.pointerID = pointer.Save(conn) + serverName, serverPortStr, err := net.SplitHostPort(server) + if err != nil { + return nil, err + } + cServerName := C.CString(serverName) + defer C.free(unsafe.Pointer(cServerName)) + serverPort, err := strconv.Atoi(serverPortStr) + if err != nil { + return nil, err + } + cCertFile := C.CString(certFile) + defer C.free(unsafe.Pointer(cCertFile)) + conn.cppConn = C.NewConnection( + conn.pointerID, + cServerName, + C.uint16_t(serverPort), + C.uint64_t(idleTimeoutMs), + cCertFile, + C.bool(unsecure), + ) + if conn.cppConn == nil { + return nil, errors.New("msquic NewConnection failed") + } + select { + case <-conn.onConnected: + return + case <-conn.onClose: + return nil, errors.New("msquic connection closed") + } +} + +// TODO quic connection层面的read和write主要指DATAGRAM扩展，有待实现 +func (c *Connection) Read(b []byte) (n int, err error) { + panic("not implemented") +} + +func (c *Connection) Write(b []byte) (n int, err error) { + panic("not implemented") +} + +func (c *Connection) LocalAddr() (addr net.Addr) { + cAddr := C.GetConnectionAddr(c.cppConn, C.bool(true)) + if cAddr == nil { + return + } + + addr, err := net.ResolveUDPAddr("udp", C.GoString(cAddr)) + if err != nil { + addr = nil + } + return +} + +func (c *Connection) RemoteAddr() (addr net.Addr) { + cAddr := C.GetConnectionAddr(c.cppConn, C.bool(false)) + if cAddr == nil { + return + } + + addr, err := net.ResolveUDPAddr("udp", C.GoString(cAddr)) + if err != nil { + addr = nil + } + return +} + +func (c *Connection) SetDeadline(t time.Time) error { + // TODO 这里实际上设置的是连接的空闲时间 + timeout := time.Since(t) / time.Millisecond + C.SetConnectionIdleTimeout(c.cppConn, C.uint64_t(timeout)) + return nil +} + +func (c *Connection) SetReadDeadline(t time.Time) error { + return c.SetDeadline(t) +} + +func (c *Connection) SetWriteDeadline(t time.Time) error { + return c.SetDeadline(t) +} + +func (c *Connection) Close() error { + c.closeOnce.Do(func() { + close(c.onClose) + }) + pointer.Unref(c.pointerID) + C.DeleteConnection(c.cppConn) + return nil +} + +func (c *Connection) OpenStream() (conn net.Conn, err error) { + s := &stream{ + onStarted: make(chan struct{}, 1), + onSend: make(chan struct{}, 1), + onClose: make(chan struct{}), + onReceive: make(chan []byte, 1), + conn: c, + } + s.pointerID = pointer.Save(s) + s.cppStream = C.OpenStream(c.cppConn, s.pointerID) + if s.cppStream == nil { + return nil, errors.New("msquic OpenStream failed") + } + select { + case <-s.onStarted: + return s, nil + case <-s.onClose: + return nil, errors.New("msquic stream closed") + } +} + +func (c *Connection) PeerStreamStarted() (conn net.Conn, err error) { + select { + case conn = <-c.onPeerStreamStarted: + case <-c.onClose: + err = errors.New("msquic connection closed") + } + return +} + +//export OnConnectionConnected +func OnConnectionConnected(cppConn, context unsafe.Pointer) { + conn, ok := pointer.Restore(context).(*Connection) + if !ok || conn == nil { + return + } + select { + case conn.onConnected <- struct{}{}: + case <-conn.onClose: + } +} + +//export OnConnectionShutdownComplete +func OnConnectionShutdownComplete(cppConn, context unsafe.Pointer) { + conn, ok := pointer.Restore(context).(*Connection) + if !ok || conn == nil { + return + } + conn.closeOnce.Do(func() { + close(conn.onClose) + }) +} + +//export OnPeerStreamStarted +func OnPeerStreamStarted(cppConn, cppStream, context unsafe.Pointer) { + conn, ok := pointer.Restore(context).(*Connection) + if !ok || conn == nil { + return + } + s := &stream{ + cppStream: cppStream, + onStarted: make(chan struct{}, 1), + onSend: make(chan struct{}, 1), + onClose: make(chan struct{}, 1), + onReceive: make(chan []byte, 1), + conn: conn, + } + s.pointerID = pointer.Save(s) + C.SetStreamContext(cppStream, s.pointerID) + select { + case conn.onPeerStreamStarted <- s: + case <-conn.onClose: + } +} diff --git a/conn/msquic/connection.cpp b/conn/msquic/connection.cpp new file mode 100644 index 00000000..f0a3a86b --- /dev/null +++ b/conn/msquic/connection.cpp @@ -0,0 +1,162 @@ +#include "connection.h" +#include "connection.hpp" +#include "quic.hpp" +#include "stream.hpp" + +Connection::Connection(void *context) : context(context) {} + +Connection::Connection(HQUIC connection) : connection(connection) { + MsQuic->SetCallbackHandler(connection, (void *)redirectCallback, this); +} + +Connection::~Connection() { + if (connection != nullptr) { + MsQuic->ConnectionClose(connection); + MsQuic->SetCallbackHandler(connection, nullptr, nullptr); + connection = nullptr; + } + if (configuration != nullptr) { + MsQuic->ConfigurationClose(configuration); + configuration = nullptr; + } +} + +bool Connection::Start(char *serverName, uint16_t serverPort, uint64_t IdleTimeoutMs, + char *certFile, bool unsecure) { + settings.IdleTimeoutMs = IdleTimeoutMs; + settings.IsSet.IdleTimeoutMs = true; + QUIC_STATUS status = MsQuic->ConfigurationOpen(Registration, &ALPN, 1, &settings, + sizeof(settings), nullptr, &configuration); + if (QUIC_FAILED(status)) { + return false; + } + + QUIC_CREDENTIAL_CONFIG credConfig = {}; + credConfig.Type = QUIC_CREDENTIAL_TYPE_NONE; + credConfig.Flags = QUIC_CREDENTIAL_FLAG_CLIENT; + if (strlen(certFile) != 0) { + // FIXME 按照 msquic 的 docs 描述，应该是这样用的，但是不知道为什么不行 + credConfig.Flags |= QUIC_CREDENTIAL_FLAG_SET_CA_CERTIFICATE_FILE; + credConfig.CaCertificateFile = certFile; + } + if (unsecure) { + credConfig.Flags |= QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION; + } + status = MsQuic->ConfigurationLoadCredential(configuration, &credConfig); + if (QUIC_FAILED(status)) { + return false; + } + + status = MsQuic->ConnectionOpen(Registration, redirectCallback, this, &connection); + if (QUIC_FAILED(status)) { + return false; + } + + status = MsQuic->ConnectionStart(connection, configuration, QUIC_ADDRESS_FAMILY_UNSPEC, + serverName, serverPort); + if (QUIC_FAILED(status)) { + return false; + } + + return true; +} + +Stream *Connection::OpenStream(void *context) { + auto stream = new Stream(context); + auto ok = stream->Start(connection); + if (!ok) { + delete stream; + stream = nullptr; + } + return stream; +} + +Stream *Connection::AcceptStream(void *context) { + auto stream = new Stream(context); + // TODO implement stream accept + auto ok = stream->Start(connection); + if (!ok) { + delete stream; + stream = nullptr; + } + return stream; +} + +char *Connection::GetAddr(bool local) { + QUIC_ADDR addr; + uint32_t addrLen = sizeof(addr); + auto flag = local ? QUIC_PARAM_CONN_LOCAL_ADDRESS : QUIC_PARAM_CONN_REMOTE_ADDRESS; + auto addrStr = local ? &localAddrStr : &remoteAddrStr; + QUIC_STATUS status = MsQuic->GetParam(connection, flag, &addrLen, &addr); + if (QUIC_FAILED(status)) { + return nullptr; + } + auto ok = QuicAddrToString(&addr, addrStr); + if (!ok) { + return nullptr; + } + return addrStr->Address; +} + +QUIC_STATUS Connection::redirectCallback(HQUIC connection, void *context, + QUIC_CONNECTION_EVENT *event) { + return ((Connection *)context)->callback(event); +} + +QUIC_STATUS Connection::callback(QUIC_CONNECTION_EVENT *event) { + Stream *stream; + // fprintf(stderr, "connection(%p) event: %s\n", this, StringEvent(event->Type)); + + switch (event->Type) { + case QUIC_CONNECTION_EVENT_CONNECTED: + OnConnectionConnected(this, context); + break; + case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_TRANSPORT: + break; + case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_PEER: + break; + case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE: + OnConnectionShutdownComplete(this, context); + break; + case QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED: + stream = new Stream(event->PEER_STREAM_STARTED.Stream); + OnPeerStreamStarted(this, stream, context); + break; + default: + break; + } + return QUIC_STATUS_SUCCESS; +} + +void Connection::SetContext(void *context) { this->context = context; } + +void Connection::SetIdleTimeout(uint64_t idleTimeoutMs) { + settings.IdleTimeoutMs = idleTimeoutMs; + settings.IsSet.IdleTimeoutMs = true; + MsQuic->SetParam(connection, QUIC_PARAM_CONN_SETTINGS, sizeof(settings), &settings); +} + +void *NewConnection(void *context, char *serverName, uint16_t serverPort, uint64_t idleTimeoutMs, + char *certFile, bool unsecure) { + auto conn = new Connection(context); + auto ok = conn->Start(serverName, serverPort, idleTimeoutMs, certFile, unsecure); + if (!ok) { + delete conn; + conn = nullptr; + } + return conn; +} + +void DeleteConnection(void *conn) { delete (Connection *)conn; } + +void *OpenStream(void *conn, void *context) { return ((Connection *)conn)->OpenStream(context); } + +void *AcceptStream(void *conn, void *context) { return ((Connection *)conn)->AcceptStream(context); } + +char *GetConnectionAddr(void *conn, bool local) { return ((Connection *)conn)->GetAddr(local); } + +void SetConnectionContext(void *conn, void *context) { ((Connection *)conn)->SetContext(context); } + +void SetConnectionIdleTimeout(void *conn, uint64_t idleTimeoutMs) { + ((Connection *)conn)->SetIdleTimeout(idleTimeoutMs); +} diff --git a/conn/msquic/connection.h b/conn/msquic/connection.h new file mode 100644 index 00000000..bcc58970 --- /dev/null +++ b/conn/msquic/connection.h @@ -0,0 +1,29 @@ +#ifndef CONNECTION_H +#define CONNECTION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +void *NewConnection(void *context, char *serverName, uint16_t serverPort, uint64_t idleTimeoutMs, + char *certFile, bool unsecure); +void DeleteConnection(void *conn); +void *OpenStream(void *conn, void *context); +void *AcceptStream(void *conn, void *context); +char *GetConnectionAddr(void *conn, bool local); +void SetConnectionContext(void *conn, void *context); +void SetConnectionIdleTimeout(void *conn, uint64_t idleTimeoutMs); + +void OnConnectionConnected(void *conn, void *context); +void OnConnectionShutdownComplete(void *conn, void *context); +void OnPeerStreamStarted(void *conn, void *stream, void *context); + +#ifdef __cplusplus +} +#endif + +#endif /* CONNECTION_H */ \ No newline at end of file diff --git a/conn/msquic/connection.hpp b/conn/msquic/connection.hpp new file mode 100644 index 00000000..8247b8ab --- /dev/null +++ b/conn/msquic/connection.hpp @@ -0,0 +1,34 @@ +#ifndef CONNECTION_HPP +#define CONNECTION_HPP + +#include + +#include "stream.hpp" + +class Connection { + public: + Connection(void *context); + Connection(HQUIC connection); + ~Connection(); + bool Start(char *serverName, uint16_t serverPort, uint64_t IdleTimeoutMs, char *certFile, + bool unsecure); + Stream *OpenStream(void *context); + Stream *AcceptStream(void *context); + char *GetAddr(bool local); + void SetContext(void *context); + void SetIdleTimeout(uint64_t idleTimeoutMs); + + private: + HQUIC configuration = {}; + HQUIC connection = {}; + void *context = {}; + QUIC_ADDR_STR localAddrStr = {}; + QUIC_ADDR_STR remoteAddrStr = {}; + QUIC_SETTINGS settings = {}; + + static QUIC_STATUS redirectCallback(HQUIC connection, void *context, + QUIC_CONNECTION_EVENT *event); + QUIC_STATUS callback(QUIC_CONNECTION_EVENT *event); +}; + +#endif /* CONNECTION_HPP */ \ No newline at end of file diff --git a/conn/msquic/listener.cpp b/conn/msquic/listener.cpp new file mode 100644 index 00000000..6c4e1d4c --- /dev/null +++ b/conn/msquic/listener.cpp @@ -0,0 +1,139 @@ +#include "listener.h" +#include "connection.hpp" +#include "quic.hpp" +#include + +class Listener { + public: + Listener(void *context) : context(context) {} + + ~Listener() { + if (listener != nullptr) { + MsQuic->ListenerClose(listener); + MsQuic->SetCallbackHandler(listener, nullptr, nullptr); + listener = nullptr; + } + if (configuration != nullptr) { + MsQuic->ConfigurationClose(configuration); + configuration = nullptr; + } + } + + bool Start(char *addr, uint64_t idleTimeoutMs, char *keyFile, char *certFile, char *password) { + QUIC_SETTINGS settings = {}; + settings.IdleTimeoutMs = idleTimeoutMs; + settings.IsSet.IdleTimeoutMs = true; + settings.ServerResumptionLevel = QUIC_SERVER_RESUME_AND_ZERORTT; + settings.IsSet.ServerResumptionLevel = true; + settings.PeerBidiStreamCount = 1024; + settings.IsSet.PeerBidiStreamCount = true; + QUIC_STATUS status = MsQuic->ConfigurationOpen(Registration, &ALPN, 1, &settings, + sizeof(settings), NULL, &configuration); + if (QUIC_FAILED(status)) { + return false; + } + + QUIC_CREDENTIAL_CONFIG CredConfig = {}; + CredConfig.Flags = QUIC_CREDENTIAL_FLAG_NONE; + if (strlen(password) == 0) { + CredConfig.Type = QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE; + QUIC_CERTIFICATE_FILE CertificateFile = {}; + CertificateFile.PrivateKeyFile = keyFile; + CertificateFile.CertificateFile = certFile; + CredConfig.CertificateFile = &CertificateFile; + std::cout << "key and cert : " << keyFile << " | " << certFile << std::endl; + } else { + CredConfig.Type = QUIC_CREDENTIAL_TYPE_CERTIFICATE_FILE_PROTECTED; + QUIC_CERTIFICATE_FILE_PROTECTED certFileProtected = {}; + certFileProtected.PrivateKeyFile = keyFile; + certFileProtected.CertificateFile = certFile; + certFileProtected.PrivateKeyPassword = password; + CredConfig.CertificateFileProtected = &certFileProtected; + } + + status = MsQuic->ConfigurationLoadCredential(configuration, &CredConfig); + if (QUIC_FAILED(status)) { + return false; + } + + auto cb = [](HQUIC listener, void *context, QUIC_LISTENER_EVENT *event) -> QUIC_STATUS { + return ((Listener *)context)->callback(event); + }; + status = MsQuic->ListenerOpen(Registration, cb, this, &listener); + if (QUIC_FAILED(status)) { + return false; + } + + QUIC_ADDR quicAddr; + auto ok = QuicAddrFromString(addr, 0, &quicAddr); + if (!ok) { + return false; + } + status = MsQuic->ListenerStart(listener, &ALPN, 1, &quicAddr); + if (QUIC_FAILED(status)) { + return false; + } + + return true; + } + + char *GetAddr() { + QUIC_ADDR addr; + uint32_t addrLen = sizeof(addr); + QUIC_STATUS status = + MsQuic->GetParam(listener, QUIC_PARAM_LISTENER_LOCAL_ADDRESS, &addrLen, &addr); + if (QUIC_FAILED(status)) { + return nullptr; + } + auto ok = QuicAddrToString(&addr, &addrStr); + if (!ok) { + return nullptr; + } + + return addrStr.Address; + } + + private: + HQUIC configuration = {}; + HQUIC listener = {}; + void *context = {}; + QUIC_ADDR_STR addrStr = {}; + + QUIC_STATUS callback(QUIC_LISTENER_EVENT *event) { + QUIC_STATUS status; + Connection *conn; + + switch (event->Type) { + case QUIC_LISTENER_EVENT_NEW_CONNECTION: + status = + MsQuic->ConnectionSetConfiguration(event->NEW_CONNECTION.Connection, configuration); + if (QUIC_FAILED(status)) { + MsQuic->ConnectionClose(event->NEW_CONNECTION.Connection); + break; + } + conn = new Connection(event->NEW_CONNECTION.Connection); + OnNewConnection(this, conn, context); + break; + case QUIC_LISTENER_EVENT_STOP_COMPLETE: + break; + default: + break; + } + return QUIC_STATUS_SUCCESS; + } +}; + +void *NewListener(char *addr, uint64_t idleTimeoutMs, char *keyFile, char *certFile, char *password, + void *context) { + auto listener = new Listener(context); + auto ok = listener->Start(addr, idleTimeoutMs, keyFile, certFile, password); + if (!ok) { + delete listener; + listener = nullptr; + } + return listener; +} + +void DeleteListener(void *listener) { delete (Listener *)listener; } + +char *GetListenerAddr(void *listener) { return ((Listener *)listener)->GetAddr(); } diff --git a/conn/msquic/listener.go b/conn/msquic/listener.go new file mode 100644 index 00000000..ac02223b --- /dev/null +++ b/conn/msquic/listener.go @@ -0,0 +1,128 @@ +package msquic + +/* +#include + +#include "connection.h" +#include "listener.h" +*/ +import "C" + +import ( + "errors" + "net" + "unsafe" + + "github.com/mattn/go-pointer" +) + +type Listener struct { + cppListener unsafe.Pointer + pointerID unsafe.Pointer + onClose chan struct{} + onNewConnection chan net.Conn +} + +func NewListenr( + addr string, + idleTimeoutMs uint64, + keyFile string, + certFile string, + password string, +) (listener *Listener, err error) { + listener = &Listener{ + onClose: make(chan struct{}), + onNewConnection: make(chan net.Conn, 1), + } + listener.pointerID = pointer.Save(listener) + cAddr := C.CString(addr) + defer C.free(unsafe.Pointer(cAddr)) + cKeyFile := C.CString(keyFile) + defer C.free(unsafe.Pointer(cKeyFile)) + cCertFile := C.CString(certFile) + defer C.free(unsafe.Pointer(cCertFile)) + cPassword := C.CString(password) + defer C.free(unsafe.Pointer(cPassword)) + listener.cppListener = C.NewListener( + cAddr, + C.uint64_t(idleTimeoutMs), + cKeyFile, + cCertFile, + cPassword, + listener.pointerID, + ) + if listener.cppListener == nil { + err = errors.New("failed to create listener") + } + return +} + +func (l *Listener) Accept() (conn net.Conn, err error) { + select { + case quicConn := <-l.onNewConnection: + newQuicConn, ok := quicConn.(*Connection) + if !ok { + return nil, errors.New("msquic not renturn a msquic connection") + } + streamConn, err := newQuicConn.PeerStreamStarted() + if streamConn == nil { + return nil, errors.New("msquic AcceptStream failed") + } + msquicConn := &MsquicConn{ + Conn: streamConn, + MsquicConnection: newQuicConn, + } + return msquicConn, err + case <-l.onClose: + err = errors.New("listener closed") + } + return +} + +func (l *Listener) Close() error { + pointer.Unref(l.pointerID) + C.DeleteListener(l.cppListener) + return nil +} + +func (l *Listener) Addr() (addr net.Addr) { + cAddr := C.GetListenerAddr(l.cppListener) + if cAddr == nil { + return + } + + addr, err := net.ResolveUDPAddr("udp", C.GoString(cAddr)) + if err != nil { + addr = nil + } + return +} + +//export OnNewConnection +func OnNewConnection(cppListener, cppConn, context unsafe.Pointer) { + listener, ok := pointer.Restore(context).(*Listener) + if !ok || listener == nil { + return + } + c := &Connection{ + cppConn: cppConn, + onConnected: make(chan struct{}, 1), + onPeerStreamStarted: make(chan net.Conn, 1), + onClose: make(chan struct{}), + } + c.pointerID = pointer.Save(c) + C.SetConnectionContext(cppConn, c.pointerID) + select { + case listener.onNewConnection <- c: + case <-listener.onClose: + } +} + +//export OnListenerStopComplete +func OnListenerStopComplete(cppListener, context unsafe.Pointer) { + listener, ok := pointer.Restore(context).(*Listener) + if !ok || listener == nil { + return + } + close(listener.onClose) +} diff --git a/conn/msquic/listener.h b/conn/msquic/listener.h new file mode 100644 index 00000000..611c9a49 --- /dev/null +++ b/conn/msquic/listener.h @@ -0,0 +1,22 @@ +#ifndef LISTENER_H +#define LISTENER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +void *NewListener(char *addr, uint64_t idleTimeoutMs, char *keyFile, char *certFile, char *password, + void *context); +void DeleteListener(void *listener); +char *GetListenerAddr(void *listener); + +void OnNewConnection(void *listener, void *conn, void *context); +void OnListenerStopComplete(void *listener, void *context); + +#ifdef __cplusplus +} +#endif + +#endif /* LISTENER_H */ \ No newline at end of file diff --git a/conn/msquic/msquicConn.go b/conn/msquic/msquicConn.go new file mode 100644 index 00000000..b871ecb6 --- /dev/null +++ b/conn/msquic/msquicConn.go @@ -0,0 +1,43 @@ +package msquic + +import ( + "crypto/tls" + "net" +) + +const msquicIdleTimeOutMs uint64 = 100_000 + +type MsquicConn struct { + net.Conn // *stream + MsquicConnection *Connection +} + +func (q *MsquicConn) Close() (err error) { + err1 := q.Conn.Close() + err2 := q.MsquicConnection.Close() + if err1 != nil { + return err1 + } + return err2 +} + +func MsquicDial(addr string, config *tls.Config) (conn net.Conn, err error) { + unsecure := config.InsecureSkipVerify + msquicConnection, err := NewConnection(addr, msquicIdleTimeOutMs, "", unsecure) + if err != nil { + return + } + stream, err := msquicConnection.OpenStream() + if err != nil { + return + } + conn = &MsquicConn{ + Conn: stream, + MsquicConnection: msquicConnection, + } + return +} + +func MsquicListen(addr string, keyFile string, certFile string) (net.Listener, error) { + return NewListenr(addr, msquicIdleTimeOutMs, keyFile, certFile, "") +} diff --git a/conn/msquic/quic.cpp b/conn/msquic/quic.cpp new file mode 100644 index 00000000..7c14a21c --- /dev/null +++ b/conn/msquic/quic.cpp @@ -0,0 +1,176 @@ +#include "quic.h" +#include "quic.hpp" + +const QUIC_API_TABLE *MsQuic = {}; +HQUIC Registration = {}; +const QUIC_BUFFER ALPN = {sizeof("default") - 1, (uint8_t *)"default"}; + +bool Init() { + QUIC_STATUS status = QUIC_STATUS_SUCCESS; + + if (MsQuic == nullptr) { + status = MsQuicOpen2((const QUIC_API_TABLE **)&MsQuic); + if (QUIC_FAILED(status)) { + goto Error; + } + + status = MsQuic->RegistrationOpen(nullptr, &Registration); + if (QUIC_FAILED(status)) { + goto Error; + } + } + return true; + +Error: + if (MsQuic != nullptr) { + if (Registration != nullptr) { + MsQuic->RegistrationClose(Registration); + Registration = nullptr; + } + MsQuicClose(MsQuic); + MsQuic = nullptr; + } + return false; +} + +const char *StringStatus(QUIC_STATUS status) { + switch (status) { + case QUIC_STATUS_SUCCESS: + return "success"; + case QUIC_STATUS_PENDING: + return "pending"; + case QUIC_STATUS_CONTINUE: + return "continue"; + case QUIC_STATUS_OUT_OF_MEMORY: + return "out of memory"; + case QUIC_STATUS_INVALID_PARAMETER: + return "invalid parameter"; + case QUIC_STATUS_INVALID_STATE: + return "invalid state"; + case QUIC_STATUS_NOT_SUPPORTED: + return "not supported"; + case QUIC_STATUS_NOT_FOUND: + return "not found"; + case QUIC_STATUS_BUFFER_TOO_SMALL: + return "buffer too small"; + case QUIC_STATUS_HANDSHAKE_FAILURE: + return "handshake failure"; + case QUIC_STATUS_ABORTED: + return "aborted"; + case QUIC_STATUS_ADDRESS_IN_USE: + return "address in use"; + case QUIC_STATUS_INVALID_ADDRESS: + return "invalid address"; + case QUIC_STATUS_CONNECTION_TIMEOUT: + return "connection timeout"; + case QUIC_STATUS_CONNECTION_IDLE: + return "connection idle"; + case QUIC_STATUS_INTERNAL_ERROR: + return "internal error"; + case QUIC_STATUS_CONNECTION_REFUSED: + return "connection refused"; + case QUIC_STATUS_PROTOCOL_ERROR: + return "protocol error"; + case QUIC_STATUS_VER_NEG_ERROR: + return "ver neg error"; + case QUIC_STATUS_UNREACHABLE: + return "unreachable"; + case QUIC_STATUS_TLS_ERROR: + return "tls error"; + case QUIC_STATUS_USER_CANCELED: + return "user canceled"; + case QUIC_STATUS_ALPN_NEG_FAILURE: + return "alpn neg failure"; + case QUIC_STATUS_STREAM_LIMIT_REACHED: + return "stream limit reached"; + case QUIC_STATUS_ALPN_IN_USE: + return "alpn in use"; + case QUIC_STATUS_ADDRESS_NOT_AVAILABLE: + return "address not available"; + case QUIC_STATUS_CLOSE_NOTIFY: + return "close notify"; + case QUIC_STATUS_BAD_CERTIFICATE: + return "bad certificate"; + case QUIC_STATUS_UNSUPPORTED_CERTIFICATE: + return "unsupported certificate"; + case QUIC_STATUS_REVOKED_CERTIFICATE: + return "revoked certificate"; + case QUIC_STATUS_EXPIRED_CERTIFICATE: + return "expired certificate"; + case QUIC_STATUS_UNKNOWN_CERTIFICATE: + return "unknown certificate"; + case QUIC_STATUS_REQUIRED_CERTIFICATE: + return "required certificate"; + case QUIC_STATUS_CERT_EXPIRED: + return "cert expired"; + case QUIC_STATUS_CERT_UNTRUSTED_ROOT: + return "cert untrusted root"; + case QUIC_STATUS_CERT_NO_CERT: + return "cert no cert"; + } + return "unknown"; +} + +const char *StringEvent(QUIC_STREAM_EVENT_TYPE type) { + switch (type) { + case QUIC_STREAM_EVENT_START_COMPLETE: + return "start complete"; + case QUIC_STREAM_EVENT_RECEIVE: + return "receive"; + case QUIC_STREAM_EVENT_SEND_COMPLETE: + return "send complete"; + case QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN: + return "peer send shutdown"; + case QUIC_STREAM_EVENT_PEER_SEND_ABORTED: + return "peer send aborted"; + case QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED: + return "peer receive aborted"; + case QUIC_STREAM_EVENT_SEND_SHUTDOWN_COMPLETE: + return "send shutdown complete"; + case QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE: + return "shutdown complete"; + case QUIC_STREAM_EVENT_IDEAL_SEND_BUFFER_SIZE: + return "ideal send buffer size"; + case QUIC_STREAM_EVENT_PEER_ACCEPTED: + return "peer accepted"; + } + return "unknown"; +} + +const char *StringEvent(QUIC_CONNECTION_EVENT_TYPE type) { + switch (type) { + case QUIC_CONNECTION_EVENT_CONNECTED: + return "connected"; + case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_TRANSPORT: + return "shutdown initiated by transport"; + case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_PEER: + return "shutdown initiated by peer"; + case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE: + return "shutdown complete"; + case QUIC_CONNECTION_EVENT_LOCAL_ADDRESS_CHANGED: + return "local address changed"; + case QUIC_CONNECTION_EVENT_PEER_ADDRESS_CHANGED: + return "peer address changed"; + case QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED: + return "peer stream started"; + case QUIC_CONNECTION_EVENT_STREAMS_AVAILABLE: + return "streams available"; + case QUIC_CONNECTION_EVENT_PEER_NEEDS_STREAMS: + return "peer needs streams"; + case QUIC_CONNECTION_EVENT_IDEAL_PROCESSOR_CHANGED: + return "ideal processor changed"; + case QUIC_CONNECTION_EVENT_DATAGRAM_STATE_CHANGED: + return "datagram state changed"; + case QUIC_CONNECTION_EVENT_DATAGRAM_RECEIVED: + return "datagram received"; + case QUIC_CONNECTION_EVENT_DATAGRAM_SEND_STATE_CHANGED: + return "datagram send state changed"; + case QUIC_CONNECTION_EVENT_RESUMED: + return "resumed"; + case QUIC_CONNECTION_EVENT_RESUMPTION_TICKET_RECEIVED: + return "resumption ticket received"; + case QUIC_CONNECTION_EVENT_PEER_CERTIFICATE_RECEIVED: + return "peer certificate received"; + } + return "unknown"; +} diff --git a/conn/msquic/quic.go b/conn/msquic/quic.go new file mode 100644 index 00000000..445ce5f3 --- /dev/null +++ b/conn/msquic/quic.go @@ -0,0 +1,13 @@ +package msquic + +/* +#include "quic.h" +*/ +import "C" + +func init() { + ok := C.Init() + if !ok { + panic("msquic init failed") + } +} diff --git a/conn/msquic/quic.h b/conn/msquic/quic.h new file mode 100644 index 00000000..3055093b --- /dev/null +++ b/conn/msquic/quic.h @@ -0,0 +1,16 @@ +#ifndef QUIC_H +#define QUIC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +bool Init(); + +#ifdef __cplusplus +} +#endif + +#endif /* QUIC_H */ \ No newline at end of file diff --git a/conn/msquic/quic.hpp b/conn/msquic/quic.hpp new file mode 100644 index 00000000..2aaf08bf --- /dev/null +++ b/conn/msquic/quic.hpp @@ -0,0 +1,14 @@ +#ifndef QUIC_HPP +#define QUIC_HPP + +#include + +extern const QUIC_API_TABLE *MsQuic; +extern HQUIC Registration; +extern const QUIC_BUFFER ALPN; + +const char *StringStatus(QUIC_STATUS status); +const char *StringEvent(QUIC_CONNECTION_EVENT_TYPE type); +const char *StringEvent(QUIC_STREAM_EVENT_TYPE type); + +#endif /* QUIC_HPP */ \ No newline at end of file diff --git a/conn/msquic/stream.cpp b/conn/msquic/stream.cpp new file mode 100644 index 00000000..24e20eb5 --- /dev/null +++ b/conn/msquic/stream.cpp @@ -0,0 +1,96 @@ +#include "stream.h" +#include "quic.hpp" +#include "stream.hpp" + +Stream::Stream(void *context) : context(context) {} + +Stream::Stream(HQUIC stream) : stream(stream) { + MsQuic->SetCallbackHandler(stream, (void *)redirectCallback, this); +} + +Stream::~Stream() { + if (stream != nullptr) { + MsQuic->StreamClose(stream); + MsQuic->SetCallbackHandler(stream, nullptr, nullptr); + stream = nullptr; + } +} + +bool Stream::Start(HQUIC connection) { + QUIC_STATUS status = MsQuic->StreamOpen(connection, QUIC_STREAM_OPEN_FLAG_0_RTT, + redirectCallback, this, &stream); + if (QUIC_FAILED(status)) { + return false; + } + + status = MsQuic->StreamStart(stream, QUIC_STREAM_START_FLAG_NONE); + if (QUIC_FAILED(status)) { + return false; + } + + return true; +} + +bool Stream::Send(void *data, uint32_t dataLen) { + sendBuffer.Buffer = (uint8_t *)data; + sendBuffer.Length = dataLen; + QUIC_STATUS status = + MsQuic->StreamSend(stream, &sendBuffer, 1, QUIC_SEND_FLAG_ALLOW_0_RTT, data); + return QUIC_SUCCEEDED(status); +} + +QUIC_STATUS Stream::callback(QUIC_STREAM_EVENT *event) { + uint32_t bufLen = 0; + void *buf = nullptr; + // fprintf(stderr, "stream(%p) event: %s\n", this, StringEvent(event->Type)); + + auto status = QUIC_STATUS_SUCCESS; + switch (event->Type) { + case QUIC_STREAM_EVENT_START_COMPLETE: + OnStreamStartComplete(this, context); + break; + case QUIC_STREAM_EVENT_SEND_COMPLETE: + free(event->SEND_COMPLETE.ClientContext); + OnStreamSendComplete(this, context); + break; + case QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE: + OnStreamShutdownComplete(this, context); + break; + case QUIC_STREAM_EVENT_RECEIVE: + for (uint32_t i = 0; i < event->RECEIVE.BufferCount; ++i) { + bufLen += event->RECEIVE.Buffers[i].Length; + } + buf = malloc(bufLen); + for (uint32_t i = 0, offset = 0; i < event->RECEIVE.BufferCount; ++i) { + memcpy((uint8_t *)buf + offset, event->RECEIVE.Buffers[i].Buffer, + event->RECEIVE.Buffers[i].Length); + offset += event->RECEIVE.Buffers[i].Length; + } + OnStreamReceive(this, context, buf, bufLen); + status = QUIC_STATUS_PENDING; + break; + default: + break; + } + return status; +} + +void Stream::ReceiveComplete(uint64_t bufferLength) { + MsQuic->StreamReceiveComplete(stream, bufferLength); +} + +QUIC_STATUS Stream::redirectCallback(HQUIC stream, void *context, QUIC_STREAM_EVENT *event) { + return ((Stream *)context)->callback(event); +}; + +void Stream::SetContext(void *context) { this->context = context; } + +void DeleteStream(void *stream) { delete (Stream *)stream; } + +void StreamSend(void *stream, void *data, size_t length) { ((Stream *)stream)->Send(data, length); } + +void StreamReceiveComplete(void *stream, uint64_t bufferLength) { + ((Stream *)stream)->ReceiveComplete(bufferLength); +} + +void SetStreamContext(void *stream, void *context) { ((Stream *)stream)->SetContext(context); } diff --git a/conn/msquic/stream.go b/conn/msquic/stream.go new file mode 100644 index 00000000..1a24794b --- /dev/null +++ b/conn/msquic/stream.go @@ -0,0 +1,144 @@ +package msquic + +/* +#include + +#include "stream.h" +*/ +import "C" + +import ( + "errors" + "io" + "net" + "sync" + "time" + "unsafe" + + "github.com/mattn/go-pointer" +) + +type stream struct { + conn *Connection + cppStream unsafe.Pointer + pointerID unsafe.Pointer + onStarted chan struct{} + onClose chan struct{} + closeOnce sync.Once + onSend chan struct{} + onReceive chan []byte + receiveBuf []byte +} + +func (s *stream) Close() error { + s.closeOnce.Do(func() { + close(s.onClose) + }) + pointer.Unref(s.pointerID) + C.DeleteStream(s.cppStream) + return nil +} + +func (s *stream) Read(b []byte) (n int, err error) { + if len(s.receiveBuf) != 0 { + n = copy(b, s.receiveBuf) + s.receiveBuf = s.receiveBuf[n:] + goto handleMsquic + } + + select { + case buf := <-s.onReceive: + n = copy(b, buf) + s.receiveBuf = buf[n:] + goto handleMsquic + case <-s.onClose: + return 0, io.EOF + } + +handleMsquic: + C.StreamReceiveComplete(s.cppStream, C.uint64_t(n)) + return +} + +func (s *stream) Write(b []byte) (n int, err error) { + cBuf := C.CBytes(b) + C.StreamSend(s.cppStream, cBuf, C.size_t(len(b))) + select { + case <-s.onSend: + return len(b), nil + case <-s.onClose: + return 0, errors.New("msquic stream closed") + } +} + +func (s *stream) LocalAddr() net.Addr { + return s.conn.LocalAddr() +} + +func (s *stream) RemoteAddr() net.Addr { + return s.conn.RemoteAddr() +} + +func (s *stream) SetDeadline(t time.Time) error { + // stream 无法单独设置超时，只能设置 connection + return s.conn.SetDeadline(t) +} + +func (s *stream) SetReadDeadline(t time.Time) error { + // stream 无法单独设置超时，只能设置 connection + return s.conn.SetReadDeadline(t) +} + +func (s *stream) SetWriteDeadline(t time.Time) error { + // stream 无法单独设置超时，只能设置 connection + return s.conn.SetWriteDeadline(t) +} + +//export OnStreamShutdownComplete +func OnStreamShutdownComplete(cppConn, context unsafe.Pointer) { + stream, ok := pointer.Restore(context).(*stream) + if !ok || stream == nil { + return + } + stream.closeOnce.Do(func() { + close(stream.onClose) + }) +} + +//export OnStreamStartComplete +func OnStreamStartComplete(cppStream, context unsafe.Pointer) { + stream, ok := pointer.Restore(context).(*stream) + if !ok || stream == nil { + return + } + select { + case stream.onStarted <- struct{}{}: + case <-stream.onClose: + } +} + +//export OnStreamReceive +func OnStreamReceive(cppStream, context, data unsafe.Pointer, length C.size_t) { + stream, ok := pointer.Restore(context).(*stream) + if !ok || stream == nil { + return + } + buf := C.GoBytes(data, C.int(length)) + defer C.free(data) + select { + case stream.onReceive <- buf: + case <-stream.onClose: + } +} + +//export OnStreamSendComplete +func OnStreamSendComplete(cppStream, context unsafe.Pointer) { + stream, ok := pointer.Restore(context).(*stream) + if !ok || stream == nil { + return + } + select { + case stream.onSend <- struct{}{}: + case <-stream.onClose: + } +} diff --git a/conn/msquic/stream.h b/conn/msquic/stream.h new file mode 100644 index 00000000..2ac97a05 --- /dev/null +++ b/conn/msquic/stream.h @@ -0,0 +1,25 @@ +#ifndef STREAM_H +#define STREAM_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +void DeleteStream(void *stream); +void StreamSend(void *stream, void *data, size_t length); +void StreamReceiveComplete(void *stream, uint64_t bufferLength); +void SetStreamContext(void *stream, void *context); + +void OnStreamStartComplete(void *stream, void *context); +void OnStreamShutdownComplete(void *stream, void *context); +void OnStreamReceive(void *stream, void *context, void *data, size_t length); +void OnStreamSendComplete(void *stream, void *context); + +#ifdef __cplusplus +} +#endif + +#endif /* STREAM_H */ \ No newline at end of file diff --git a/conn/msquic/stream.hpp b/conn/msquic/stream.hpp new file mode 100644 index 00000000..d13586fd --- /dev/null +++ b/conn/msquic/stream.hpp @@ -0,0 +1,25 @@ +#ifndef STREAM_HPP +#define STREAM_HPP + +#include + +class Stream { + public: + Stream(void *context); + Stream(HQUIC stream); + ~Stream(); + bool Start(HQUIC connection); + bool Send(void *data, uint32_t dataLen); + void ReceiveComplete(uint64_t bufferLength); + void SetContext(void *context); + + private: + HQUIC stream = {}; + void *context = {}; + QUIC_BUFFER sendBuffer = {}; + + QUIC_STATUS callback(QUIC_STREAM_EVENT *event); + static QUIC_STATUS redirectCallback(HQUIC stream, void *context, QUIC_STREAM_EVENT *event); +}; + +#endif /* STREAM_HPP */ \ No newline at end of file diff --git a/conn/quicConn.go b/conn/quicConn.go new file mode 100644 index 00000000..af587f32 --- /dev/null +++ b/conn/quicConn.go @@ -0,0 +1,161 @@ +package conn + +import ( + "context" + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" + "crypto/tls" + "crypto/x509" + "encoding/pem" + "github.com/isrc-cas/gt/predef" + "github.com/quic-go/quic-go" + "math/big" + "net" + "sync/atomic" + "time" +) + +const probePacketLostTimeOutMs = 5 + +type QuicConnection struct { + quic.Connection + quic.Stream +} + +type QuicListener struct { + quic.Listener +} + +var _ net.Conn = &QuicConnection{} +var _ net.Listener = &QuicListener{} + +func QuicDial(addr string, config *tls.Config) (net.Conn, error) { + config.NextProtos = []string{"gt-quic"} + conn, err := quic.DialAddr(context.Background(), addr, config, &quic.Config{EnableDatagrams: true}) + if err != nil { + panic(err) + } + stream, err := conn.OpenStreamSync(context.Background()) + if err != nil { + panic(err) + } + nc := &QuicConnection{ + Connection: conn, + Stream: stream, + } + return nc, err +} + +func QuicListen(addr string, config *tls.Config) (net.Listener, error) { + config.NextProtos = []string{"gt-quic"} + listener, err := quic.ListenAddr(addr, config, &quic.Config{EnableDatagrams: true}) + if err != nil { + panic(err) + } + ln := &QuicListener{ + Listener: *listener, + } + return ln, err +} + +func (ln *QuicListener) Accept() (net.Conn, error) { + conn, _ := ln.Listener.Accept(context.Background()) + stream, err := conn.AcceptStream(context.Background()) + nc := &QuicConnection{ + Connection: conn, + Stream: stream, + } + return nc, err +} + +func GenerateTLSConfig() *tls.Config { + ecdsaKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + if err != nil { + panic(err) + } + template := x509.Certificate{SerialNumber: big.NewInt(1)} + certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &ecdsaKey.PublicKey, ecdsaKey) + if err != nil { + panic(err) + } + keyBytes, err := x509.MarshalECPrivateKey(ecdsaKey) + if err != nil { + panic(err) + } + keyPEM := pem.EncodeToMemory(&pem.Block{Type: "ECDSA PRIVATE KEY", Bytes: keyBytes}) + certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER}) + + tlsCert, err := tls.X509KeyPair(certPEM, keyPEM) + if err != nil { + panic(err) + } + return &tls.Config{ + Certificates: []tls.Certificate{tlsCert}, + NextProtos: []string{"gt-quic"}, + } +} + +func GetQuicProbesResults(addr string) (avgRtt float64, pktLoss float64, err error) { + totalNum := 100 + var totalSuccessNum int64 = 0 + var totalDelay int64 = 0 + var buf []byte + probeCloseError := &quic.ApplicationError{ + Remote: false, + ErrorCode: 0x42, + ErrorMessage: "close QUIC probe connection", + } + tlsConfig := &tls.Config{} + tlsConfig.InsecureSkipVerify = true + + conn, err := QuicDial(addr, tlsConfig) + if err != nil { + return + } + sendBuffer := []byte{predef.MagicNumber, 0x02} + _, err = conn.Write(sendBuffer) + if err != nil { + return + } + + for i := 0; i < totalNum; i++ { + go func() { + err = conn.(*QuicConnection).SendMessage([]byte(time.Now().Format("2006-01-02 15:04:05.000000000"))) + if err != nil { + return + } + }() + } + + for { + timer := time.AfterFunc(probePacketLostTimeOutMs*time.Second, func() { + err = conn.(*QuicConnection).CloseWithError(0x42, "close QUIC probe connection") + if err != nil { + return + } + }) + buf, err = conn.(*QuicConnection).ReceiveMessage() + if err != nil { + // QUIC的stream关闭时会返回io.EOF，但是QUIC的不可靠数据包Datagram是在connection层面进行发送的 + // 因此需要通过quic.ApplicationError判断QUIC connection是否由于应用程序主动关闭 + if err.Error() == probeCloseError.Error() { + err = nil + break + } else { + return + } + } + if buf != nil { + sendTine, _ := time.ParseInLocation("2006-01-02 15:04:05.000000000", string(buf), time.Local) + interval := time.Now().Sub(sendTine).Microseconds() + atomic.AddInt64(&totalSuccessNum, 1) + atomic.AddInt64(&totalDelay, interval) + } + timer.Stop() + } + + avgRtt = float64(atomic.LoadInt64(&totalDelay)) / (float64(1000 * totalNum)) + pktLoss = 1 - float64(atomic.LoadInt64(&totalSuccessNum))/float64(totalNum) + return +} diff --git a/conn/quicXgboost.go b/conn/quicXgboost.go new file mode 100644 index 00000000..4ac2c535 --- /dev/null +++ b/conn/quicXgboost.go @@ -0,0 +1,14064 @@ +// 基于网络数据训练的XGBOOST模型，通过输入10种网络参数来判断在TCP和QUIC之间进行切换 +// 其中，第5个参数是Average RTT，第6个参数是Retransmission Rate（也就是Loss Rate） +// input的是个参数分别为以下内容： +// （1）Conn_num：建立的连接connection的数量； +// （2）Ttfb_rate：Ttfb/Ttfb_avg； +// （3）Duration：统计网络情况的时间窗口长度； +// （4）Ttfb：单向延迟，从cline发包到server接受； +// （5）Rtt：平均往返时延； +// （6）Retran：重传率，约等于丢包率； +// （7）Sends：每秒接受的HTTP请求数； +// （8）Body_recv：每秒接受的THHP请求的字节数； +// （9）Ttfb_avg：平均单项延迟； +// （10）Performance：每秒接受的字节数； + +package conn + +import "math" + +func PredictWithRttAndLoss(input []float64) (output []float64) { + // 0.0, 714.0, 0.0, 1.0 + minmax := [40]float64{59.98, 25034.82, 17.07, 19686.81, 0.0, 714.0, 0.0, 1.0, 0.0, 0.04, 0.0, 5.97, 0.0, 64.95, 0.05, 173.0, 0.0, 3653.28, 1444.62, 22247439.28, 0.78, 332.95, 0.0, 3653.28, 1.05, 24609.41, 0.0, 0.0, 1470.8, 23098448.76, 17.0, 55957.0, 0.01, 346.34, 22.0, 7648.0, 0.02, 19.7, 4.0, 3329.0} + index := [10]int{19, 18, 0, 1, 2, 3, 10, 12, 17, 16} + var min, max float64 + var i int + for i = 0; i < 10; i++ { + if i == 4 || i == 5 { + min = minmax[(index[i])*2] + max = minmax[(index[i])*2+1] + input[i] = (input[i] - min) / (max - min) + } else { + input[i] = 0.5 + } + } + output = PredictQuic(input) + return +} + +func PredictQuic(input []float64) (output []float64) { + var var0 float64 + if (input[5]) >= (0.0149999997) { + if (input[0]) >= (0.159849614) { + if (input[0]) >= (0.216691732) { + var0 = -0.572813094 + } else { + var0 = -0.311111122 + } + } else { + if (input[8]) >= (0.0152766854) { + var0 = 0.444334298 + } else { + var0 = 0.0242833067 + } + } + } else { + if (input[0]) >= (0.00436090212) { + if (input[8]) >= (0.031930238) { + var0 = 0.0370392464 + } else { + var0 = -0.353850394 + } + } else { + if (input[8]) >= (0.00963808037) { + var0 = 0.36658439 + } else { + var0 = -0.283420235 + } + } + } + var var1 float64 + if (input[5]) >= (0.0149999997) { + if (input[4]) >= (0.454481781) { + if (input[8]) >= (0.0550091788) { + var1 = -0.42011413 + } else { + var1 = 0.192185894 + } + } else { + if (input[1]) >= (0.00584349595) { + var1 = 0.264506042 + } else { + var1 = -0.145630911 + } + } + } else { + if (input[8]) >= (0.0147521636) { + if (input[4]) >= (0.586134434) { + var1 = -0.5554263 + } else { + var1 = -0.00105327053 + } + } else { + if (input[4]) >= (0.0231092442) { + var1 = -0.386027604 + } else { + var1 = -0.043842759 + } + } + } + var var2 float64 + if (input[0]) >= (0.121954888) { + if (input[0]) >= (0.215488732) { + if (input[0]) >= (0.286766917) { + var2 = -0.531239867 + } else { + var2 = -0.41979903 + } + } else { + if (input[5]) >= (0.0649999976) { + var2 = -0.0372177586 + } else { + var2 = -0.35158816 + } + } + } else { + if (input[5]) >= (0.0350000001) { + if (input[5]) >= (0.075000003) { + var2 = 0.378035128 + } else { + var2 = 0.237042323 + } + } else { + if (input[4]) >= (0.171568632) { + var2 = 0.220630035 + } else { + var2 = -0.138115883 + } + } + } + var var3 float64 + if (input[0]) >= (0.00586466165) { + if (input[3]) >= (0.00966230407) { + if (input[0]) >= (0.121654138) { + var3 = -0.202393159 + } else { + var3 = 0.183222726 + } + } else { + if (input[1]) >= (0.0266768299) { + var3 = -0.292001992 + } else { + var3 = 0.0334668532 + } + } + } else { + if (input[1]) >= (0.0363312997) { + if (input[3]) >= (0.0055948887) { + var3 = 0.356681138 + } else { + var3 = 0.0126470951 + } + } else { + if (input[1]) >= (0.0261687003) { + var3 = 0.305369139 + } else { + var3 = 0.466962814 + } + } + } + var var4 float64 + if (input[5]) >= (0.0149999997) { + if (input[0]) >= (0.155338347) { + if (input[0]) >= (0.230827063) { + var4 = -0.383458346 + } else { + var4 = -0.197610915 + } + } else { + if (input[8]) >= (0.015670076) { + var4 = 0.221789971 + } else { + var4 = -0.0485177711 + } + } + } else { + if (input[0]) >= (0.00646616518) { + if (input[8]) >= (0.0219643321) { + var4 = 0.00712656416 + } else { + var4 = -0.272471577 + } + } else { + if (input[8]) >= (0.0135719907) { + var4 = 0.432083249 + } else { + var4 = 0.00331402221 + } + } + } + var var5 float64 + if (input[8]) >= (0.0147521636) { + if (input[4]) >= (0.565126061) { + if (input[2]) >= (0.0166273341) { + var5 = -0.349328935 + } else { + var5 = 0.249086246 + } + } else { + if (input[8]) >= (0.0329792798) { + var5 = 0.106953658 + } else { + var5 = -0.0184853766 + } + } + } else { + if (input[8]) >= (0.0108182533) { + if (input[5]) >= (0.0949999988) { + var5 = 0.439800948 + } else { + var5 = -0.254668027 + } + } else { + if (input[4]) >= (0.0231092442) { + var5 = -0.0696059614 + } else { + var5 = 0.157901287 + } + } + } + var var6 float64 + if (input[8]) >= (0.015014424) { + if (input[2]) >= (0.0036883119) { + if (input[8]) >= (0.0325858891) { + var6 = 0.0545697547 + } else { + var6 = -0.0370239913 + } + } else { + if (input[9]) >= (0.0732538328) { + var6 = 0.323456496 + } else { + var6 = 0.133118644 + } + } + } else { + if (input[8]) >= (0.0106871231) { + if (input[7]) >= (8.55400358e-05) { + var6 = -0.193980068 + } else { + var6 = 0.150658861 + } + } else { + if (input[6]) >= (0.00787247531) { + var6 = -0.263908774 + } else { + var6 = 0.118103497 + } + } + } + var var7 float64 + if (input[0]) >= (0.1075188) { + if (input[2]) >= (0.0375131518) { + if (input[0]) >= (0.176090226) { + var7 = -0.344046384 + } else { + var7 = -0.0107122902 + } + } else { + if (input[1]) >= (0.0419207327) { + var7 = -0.567163348 + } else { + var7 = -0.240396991 + } + } + } else { + if (input[5]) >= (0.0649999976) { + if (input[4]) >= (0.495098054) { + var7 = -0.68991518 + } else { + var7 = 0.267367035 + } + } else { + if (input[4]) >= (0.217787117) { + var7 = 0.258573234 + } else { + var7 = -0.0335255414 + } + } + } + var var8 float64 + if (input[0]) >= (0.0172932334) { + if (input[3]) >= (0.00642814813) { + if (input[0]) >= (0.122255638) { + var8 = -0.142944843 + } else { + var8 = 0.0434174277 + } + } else { + if (input[0]) >= (0.0278195478) { + var8 = -0.266739219 + } else { + var8 = -0.119459212 + } + } + } else { + if (input[4]) >= (0.132352948) { + if (input[0]) >= (0.00766917318) { + var8 = 0.479572266 + } else { + var8 = 0.335826516 + } + } else { + if (input[0]) >= (0.00827067718) { + var8 = -0.0726271048 + } else { + var8 = 0.151928633 + } + } + } + var var9 float64 + if (input[0]) >= (0.0121804513) { + if (input[8]) >= (0.0325858891) { + if (input[0]) >= (0.084360905) { + var9 = -0.109497108 + } else { + var9 = 0.257994056 + } + } else { + if (input[0]) >= (0.0275187977) { + var9 = -0.341441959 + } else { + var9 = -0.0719165206 + } + } + } else { + if (input[8]) >= (0.0135719907) { + if (input[1]) >= (0.139989838) { + var9 = -0.0641734675 + } else { + var9 = 0.328368425 + } + } else { + if (input[0]) >= (0.00105263153) { + var9 = -0.111253507 + } else { + var9 = 0.282268524 + } + } + } + var var10 float64 + if (input[5]) >= (0.0649999976) { + if (input[5]) >= (0.625) { + if (input[4]) >= (0.172969192) { + var10 = -0.660194814 + } else { + var10 = -0.204253778 + } + } else { + if (input[4]) >= (0.416666687) { + var10 = -0.14922218 + } else { + var10 = 0.145580709 + } + } + } else { + if (input[1]) >= (0.0398882106) { + if (input[1]) >= (0.0546239838) { + var10 = 0.00831717253 + } else { + var10 = -0.196665064 + } + } else { + if (input[4]) >= (0.622549057) { + var10 = -0.336426407 + } else { + var10 = 0.0308342408 + } + } + } + var var11 float64 + if (input[8]) >= (0.0167191196) { + if (input[4]) >= (0.623949587) { + if (input[3]) >= (0.143703982) { + var11 = 0.431336462 + } else { + var11 = -0.319225132 + } + } else { + if (input[8]) >= (0.111657485) { + var11 = 0.151656374 + } else { + var11 = 0.0258173104 + } + } + } else { + if (input[4]) >= (0.0231092442) { + if (input[8]) >= (0.00793338567) { + var11 = -0.161223009 + } else { + var11 = 0.412308931 + } + } else { + if (input[4]) >= (0.0161064435) { + var11 = 0.153145105 + } else { + var11 = -0.228751853 + } + } + } + var var12 float64 + if (input[0]) >= (0.0175939836) { + if (input[0]) >= (0.2106767) { + if (input[0]) >= (0.286466181) { + var12 = -0.38020426 + } else { + var12 = -0.200548694 + } + } else { + if (input[2]) >= (0.0153922904) { + var12 = 0.0264828317 + } else { + var12 = -0.130721197 + } + } + } else { + if (input[1]) >= (0.0256605688) { + if (input[0]) >= (0.00436090212) { + var12 = -0.0115547795 + } else { + var12 = 0.151040763 + } + } else { + if (input[5]) >= (0.0549999997) { + var12 = 0.208390415 + } else { + var12 = 0.346486598 + } + } + } + var var13 float64 + if (input[0]) >= (0.181804508) { + if (input[8]) >= (0.0557959601) { + if (input[8]) >= (0.166076586) { + var13 = -0.113172494 + } else { + var13 = -0.314911723 + } + } else { + if (input[4]) >= (0.0357142873) { + var13 = -0.0658165365 + } else { + var13 = 0.60520792 + } + } + } else { + if (input[8]) >= (0.0337660648) { + if (input[0]) >= (0.0663157851) { + var13 = -0.0417664088 + } else { + var13 = 0.240204453 + } + } else { + if (input[0]) >= (0.0212030075) { + var13 = -0.208579049 + } else { + var13 = 0.056724593 + } + } + } + var var14 float64 + if (input[8]) >= (0.0167191196) { + if (input[0]) >= (0.0275187977) { + if (input[8]) >= (0.0308811963) { + var14 = 0.0174447391 + } else { + var14 = -0.222359404 + } + } else { + if (input[4]) >= (0.15196079) { + var14 = 0.394873649 + } else { + var14 = 0.110791735 + } + } + } else { + if (input[0]) >= (0.00827067718) { + if (input[4]) >= (0.116946779) { + var14 = -0.0899498239 + } else { + var14 = -0.3130413 + } + } else { + if (input[8]) >= (0.0133097302) { + var14 = 0.211262539 + } else { + var14 = -0.00744245201 + } + } + } + var var15 float64 + if (input[0]) >= (0.286466181) { + var15 = -0.343626708 + } else { + if (input[8]) >= (0.106412277) { + if (input[4]) >= (0.667366982) { + var15 = -0.276257426 + } else { + var15 = 0.228582308 + } + } else { + if (input[0]) >= (0.0882706791) { + var15 = -0.13722305 + } else { + var15 = 0.0201168247 + } + } + } + var var16 float64 + if (input[0]) >= (0.286466181) { + var16 = -0.32989648 + } else { + if (input[1]) >= (0.0251524393) { + if (input[3]) >= (0.00777463242) { + var16 = 0.0254658889 + } else { + var16 = -0.079253532 + } + } else { + if (input[0]) >= (0.0353383459) { + var16 = -0.0234273244 + } else { + var16 = 0.189634115 + } + } + } + var var17 float64 + if (input[8]) >= (0.0712693408) { + if (input[5]) >= (0.625) { + if (input[5]) >= (0.855000019) { + var17 = -0.663322926 + } else { + var17 = -0.271148592 + } + } else { + if (input[7]) >= (0.000999253942) { + var17 = 0.0624868572 + } else { + var17 = 0.208845958 + } + } + } else { + if (input[1]) >= (0.039380081) { + if (input[1]) >= (0.0561483726) { + var17 = 0.00382913044 + } else { + var17 = -0.134786919 + } + } else { + if (input[2]) >= (0.0916712582) { + var17 = -0.317375243 + } else { + var17 = 0.0267927125 + } + } + } + var var18 float64 + if (input[0]) >= (0.00436090212) { + if (input[3]) >= (0.00614878489) { + if (input[0]) >= (0.216691732) { + var18 = -0.25690043 + } else { + var18 = 0.0211390778 + } + } else { + if (input[0]) >= (0.0230075195) { + var18 = -0.143771589 + } else { + var18 = -0.0207569618 + } + } + } else { + if (input[4]) >= (0.0259103645) { + if (input[4]) >= (0.0882352963) { + var18 = 0.0731432587 + } else { + var18 = 0.451496929 + } + } else { + if (input[4]) >= (0.021708684) { + var18 = -0.301004559 + } else { + var18 = 0.163224563 + } + } + } + var var19 float64 + if (input[8]) >= (0.0165879875) { + if (input[0]) >= (0.0275187977) { + if (input[8]) >= (0.0303566754) { + var19 = 0.0221756846 + } else { + var19 = -0.166503578 + } + } else { + if (input[4]) >= (0.15196079) { + var19 = 0.334065378 + } else { + var19 = 0.0631137416 + } + } + } else { + if (input[0]) >= (0.00827067718) { + if (input[4]) >= (0.116946779) { + var19 = -0.058943741 + } else { + var19 = -0.282993317 + } + } else { + if (input[4]) >= (0.0161064435) { + var19 = 0.0625061542 + } else { + var19 = -0.216944978 + } + } + } + var var20 float64 + if (input[0]) >= (0.104210526) { + if (input[8]) >= (0.0708759502) { + if (input[0]) >= (0.122255638) { + var20 = -0.0727870241 + } else { + var20 = 0.271377712 + } + } else { + if (input[4]) >= (0.14635855) { + var20 = -0.373509854 + } else { + var20 = 0.0388139226 + } + } + } else { + if (input[8]) >= (0.0344217159) { + if (input[4]) >= (0.174369752) { + var20 = -0.0201347563 + } else { + var20 = 0.232145876 + } + } else { + if (input[4]) >= (0.203781515) { + var20 = 0.179765791 + } else { + var20 = -0.0439592823 + } + } + } + var var21 float64 + if (input[0]) >= (0.0121804513) { + if (input[8]) >= (0.0255048517) { + if (input[0]) >= (0.0326315798) { + var21 = -0.0227400903 + } else { + var21 = 0.263679087 + } + } else { + if (input[0]) >= (0.0681203008) { + var21 = 0.71792233 + } else { + var21 = -0.16471675 + } + } + } else { + if (input[8]) >= (0.0135719907) { + if (input[4]) >= (0.0315126069) { + var21 = 0.277873278 + } else { + var21 = 0.054375086 + } + } else { + if (input[0]) >= (0.00105263153) { + var21 = -0.0604105964 + } else { + var21 = 0.192309693 + } + } + } + var var22 float64 + if (input[5]) >= (0.114999995) { + if (input[8]) >= (0.0310123265) { + if (input[3]) >= (0.00515766861) { + var22 = 0.0904029608 + } else { + var22 = -0.170648903 + } + } else { + if (input[8]) >= (0.0230133757) { + var22 = 0.284125447 + } else { + var22 = 0.402268916 + } + } + } else { + if (input[6]) >= (0.0547460616) { + if (input[6]) >= (0.177966103) { + var22 = -0.555282474 + } else { + var22 = -0.137755647 + } + } else { + if (input[1]) >= (0.0419207327) { + var22 = -0.0501996242 + } else { + var22 = 0.0169438105 + } + } + } + var var23 float64 + if (input[4]) >= (0.618347347) { + if (input[0]) >= (0.0557894707) { + if (input[2]) >= (0.111178294) { + var23 = -0.0808938742 + } else { + var23 = -0.326835692 + } + } else { + var23 = 0.394457906 + } + } else { + if (input[0]) >= (0.286466181) { + var23 = -0.315463096 + } else { + if (input[5]) >= (0.114999995) { + var23 = 0.0944778845 + } else { + var23 = -0.0043493635 + } + } + } + var var24 float64 + if (input[8]) >= (0.133556262) { + if (input[4]) >= (0.0875350162) { + if (input[5]) >= (0.474999994) { + var24 = -0.176793694 + } else { + var24 = 0.237827122 + } + } else { + if (input[2]) >= (0.230654538) { + var24 = -0.550774276 + } else { + var24 = -0.139267176 + } + } + } else { + if (input[4]) >= (0.415266097) { + if (input[5]) >= (0.0949999988) { + var24 = -0.492633671 + } else { + var24 = -0.101628713 + } + } else { + if (input[8]) >= (0.0723183826) { + var24 = 0.0746133849 + } else { + var24 = -0.01057842 + } + } + } + var var25 float64 + if (input[8]) >= (0.00793338567) { + if (input[8]) >= (0.00911355857) { + if (input[4]) >= (0.640756309) { + var25 = -0.242975041 + } else { + var25 = 0.0066553154 + } + } else { + if (input[4]) >= (0.0259103645) { + var25 = 0.560866177 + } else { + var25 = -0.32564646 + } + } + } else { + if (input[1]) >= (0.0434451215) { + if (input[8]) >= (0.00491738785) { + var25 = 0.0347166434 + } else { + var25 = 0.484109372 + } + } else { + var25 = 0.748150885 + } + } + var var26 float64 + if (input[0]) >= (0.00285714283) { + if (input[8]) >= (0.0143587729) { + if (input[0]) >= (0.0145864664) { + var26 = -0.00986585487 + } else { + var26 = 0.121390909 + } + } else { + if (input[8]) >= (0.0106871231) { + var26 = -0.183703855 + } else { + var26 = 0.0568781793 + } + } + } else { + if (input[8]) >= (0.00937581994) { + if (input[0]) >= (0.00105263153) { + var26 = 0.19825463 + } else { + var26 = 0.389317423 + } + } else { + if (input[8]) >= (0.00832677633) { + var26 = -0.347230077 + } else { + var26 = -0.129909441 + } + } + } + var var27 float64 + if (input[0]) >= (0.00827067718) { + if (input[8]) >= (0.015670076) { + if (input[9]) >= (0.176666766) { + var27 = -0.263784438 + } else { + var27 = 0.0073127728 + } + } else { + if (input[5]) >= (0.075000003) { + var27 = 0.429045528 + } else { + var27 = -0.256443411 + } + } + } else { + if (input[8]) >= (0.0133097302) { + if (input[8]) >= (0.0379622355) { + var27 = -0.565389395 + } else { + var27 = 0.168336481 + } + } else { + if (input[6]) >= (0.00754131936) { + var27 = -0.101397805 + } else { + var27 = 0.077026993 + } + } + } + var var28 float64 + if (input[0]) >= (0.0921804532) { + if (input[8]) >= (0.0716627315) { + if (input[0]) >= (0.185112774) { + var28 = -0.229581967 + } else { + var28 = 0.0519057326 + } + } else { + if (input[4]) >= (0.226190478) { + var28 = -0.330083191 + } else { + var28 = -0.0124392314 + } + } + } else { + if (input[8]) >= (0.0454366654) { + if (input[4]) >= (0.172969192) { + var28 = 0.0542706922 + } else { + var28 = 0.262478292 + } + } else { + if (input[4]) >= (0.262605071) { + var28 = 0.19488956 + } else { + var28 = -0.0242337324 + } + } + } + var var29 float64 + if (input[1]) >= (0.207571134) { + if (input[8]) >= (0.0231445059) { + if (input[0]) >= (0.128421053) { + var29 = -0.0468559712 + } else { + var29 = -0.685421646 + } + } else { + if (input[0]) >= (0.00586466165) { + var29 = -0.291550547 + } else { + var29 = 0.0851533562 + } + } + } else { + if (input[0]) >= (0.0545864664) { + if (input[8]) >= (0.0264227651) { + var29 = -0.0538973771 + } else { + var29 = 0.278168768 + } + } else { + if (input[8]) >= (0.0299632829) { + var29 = 0.135819137 + } else { + var29 = -0.0228871312 + } + } + } + var var30 float64 + if (input[0]) >= (0.0175939836) { + if (input[8]) >= (0.0295698922) { + if (input[0]) >= (0.0509774461) { + var30 = -0.0362095311 + } else { + var30 = 0.134576112 + } + } else { + if (input[4]) >= (0.189775914) { + var30 = 0.110627048 + } else { + var30 = -0.162670135 + } + } + } else { + if (input[4]) >= (0.14775911) { + if (input[8]) >= (0.0131786) { + var30 = 0.28423661 + } else { + var30 = -0.284755439 + } + } else { + if (input[3]) >= (0.00302774715) { + var30 = -0.021532381 + } else { + var30 = 0.0976749361 + } + } + } + var var31 float64 + if (input[8]) >= (0.138145819) { + if (input[0]) >= (0.221503764) { + var31 = -0.316284448 + } else { + if (input[4]) >= (0.0693277344) { + var31 = 0.23669593 + } else { + var31 = -0.115045242 + } + } + } else { + if (input[0]) >= (0.122255638) { + if (input[4]) >= (0.172969192) { + var31 = -0.15549694 + } else { + var31 = 0.0663940087 + } + } else { + if (input[8]) >= (0.0708759502) { + var31 = 0.180226147 + } else { + var31 = -0.0127736554 + } + } + } + var var32 float64 + if (input[0]) >= (0.00285714283) { + if (input[4]) >= (0.021708684) { + if (input[4]) >= (0.032913167) { + var32 = -0.00954950042 + } else { + var32 = 0.102335446 + } + } else { + if (input[5]) >= (0.00499999989) { + var32 = 0.0681381673 + } else { + var32 = -0.295330226 + } + } + } else { + if (input[4]) >= (0.021708684) { + if (input[4]) >= (0.0259103645) { + var32 = 0.226346865 + } else { + var32 = -0.390549183 + } + } else { + if (input[4]) >= (0.0161064435) { + var32 = 0.294218421 + } else { + var32 = -0.17620708 + } + } + } + var var33 float64 + if (input[5]) >= (0.86500001) { + if (input[8]) >= (0.0506818779) { + if (input[0]) >= (0.124360904) { + var33 = -0.461648107 + } else { + var33 = -0.971438646 + } + } else { + var33 = -0.0222659539 + } + } else { + if (input[8]) >= (0.0990689769) { + if (input[0]) >= (0.2218045) { + var33 = -0.271005005 + } else { + var33 = 0.119335398 + } + } else { + if (input[0]) >= (0.0281203017) { + var33 = -0.039206557 + } else { + var33 = 0.0298813786 + } + } + } + var var34 float64 + if (input[2]) >= (0.400580525) { + if (input[0]) >= (0.120300755) { + if (input[1]) >= (0.118902437) { + var34 = 0.0354767926 + } else { + var34 = -0.474155307 + } + } else { + var34 = -1.15165257 + } + } else { + if (input[6]) >= (0.0760905594) { + if (input[8]) >= (0.0711382106) { + var34 = 0.0793998465 + } else { + var34 = -0.215196773 + } + } else { + if (input[3]) >= (0.0115392981) { + var34 = 0.0383832827 + } else { + var34 = -0.01483439 + } + } + } + var var35 float64 + if (input[0]) >= (0.00436090212) { + if (input[8]) >= (0.0171125103) { + if (input[0]) >= (0.0275187977) { + var35 = -0.015087246 + } else { + var35 = 0.0594244488 + } + } else { + if (input[0]) >= (0.00827067718) { + var35 = -0.156426743 + } else { + var35 = 0.00703513715 + } + } + } else { + if (input[8]) >= (0.00950695015) { + if (input[0]) >= (0.00105263153) { + var35 = 0.0771276727 + } else { + var35 = 0.344308347 + } + } else { + if (input[0]) >= (0.00345864659) { + var35 = 0.239082128 + } else { + var35 = -0.212378129 + } + } + } + var var36 float64 + if (input[6]) >= (0.0212692283) { + if (input[2]) >= (0.0046602902) { + if (input[6]) >= (0.147138506) { + var36 = -0.32909283 + } else { + var36 = -0.014357632 + } + } else { + if (input[0]) >= (0.00315789459) { + var36 = -0.230289802 + } else { + var36 = 0.000359835918 + } + } + } else { + if (input[0]) >= (0.000150375941) { + if (input[0]) >= (0.00105263153) { + var36 = 0.0080949543 + } else { + var36 = 0.210141391 + } + } else { + var36 = -0.445842773 + } + } + var var37 float64 + if (input[4]) >= (0.684173703) { + if (input[3]) >= (0.171706378) { + var37 = 0.128316104 + } else { + var37 = -0.320279062 + } + } else { + if (input[8]) >= (0.0833333358) { + if (input[4]) >= (0.0553221293) { + var37 = 0.0878700837 + } else { + var37 = -0.1695389 + } + } else { + if (input[4]) >= (0.0665266141) { + var37 = -0.0263895858 + } else { + var37 = 0.0276795719 + } + } + } + var var38 float64 + if (input[0]) >= (0.286466181) { + var38 = -0.299754083 + } else { + if (input[0]) >= (0.275338352) { + if (input[8]) >= (0.0689089969) { + var38 = -0.25500527 + } else { + var38 = 0.948396266 + } + } else { + if (input[7]) >= (0.0112215932) { + var38 = 0.0329480879 + } else { + var38 = -0.012819035 + } + } + } + var var39 float64 + if (input[4]) >= (0.685574234) { + if (input[3]) >= (0.159394085) { + var39 = 0.0372105427 + } else { + var39 = -0.307810545 + } + } else { + if (input[9]) >= (0.00859007239) { + if (input[0]) >= (0.121654138) { + var39 = -0.0721839815 + } else { + var39 = 0.00283383112 + } + } else { + if (input[2]) >= (0.334310651) { + var39 = -0.369843483 + } else { + var39 = 0.0615457594 + } + } + } + var var40 float64 + if (input[6]) >= (0.0952674896) { + if (input[5]) >= (0.254999995) { + var40 = 0.266057879 + } else { + if (input[6]) >= (0.189135075) { + var40 = -0.455252081 + } else { + var40 = -0.16092959 + } + } + } else { + if (input[1]) >= (0.254065037) { + if (input[5]) >= (0.204999998) { + var40 = 0.171405852 + } else { + var40 = -0.497929841 + } + } else { + if (input[8]) >= (0.165683195) { + var40 = 0.140502438 + } else { + var40 = -0.00324732484 + } + } + } + var var41 float64 + if (input[4]) >= (0.633753538) { + if (input[3]) >= (0.165618598) { + var41 = 0.318831801 + } else { + if (input[2]) >= (0.0165836904) { + var41 = -0.277226508 + } else { + var41 = 0.200899377 + } + } + } else { + if (input[3]) >= (0.0225597806) { + if (input[5]) >= (0.0149999997) { + var41 = -0.0186447985 + } else { + var41 = 0.107980765 + } + } else { + if (input[3]) >= (0.00298046647) { + var41 = -0.0198372789 + } else { + var41 = 0.0463156216 + } + } + } + var var42 float64 + if (input[8]) >= (0.00793338567) { + if (input[5]) >= (0.784999967) { + if (input[8]) >= (0.0517964847) { + var42 = -0.501639068 + } else { + var42 = 0.173977554 + } + } else { + if (input[8]) >= (0.0143587729) { + var42 = 0.00614444446 + } else { + var42 = -0.0434169993 + } + } + } else { + if (input[0]) >= (0.00616541365) { + if (input[1]) >= (0.101371951) { + var42 = 0.37578845 + } else { + var42 = -0.275188982 + } + } else { + if (input[4]) >= (0.0154061634) { + var42 = 0.45450744 + } else { + var42 = -0.088946268 + } + } + } + var var43 float64 + if (input[0]) >= (0.28406015) { + var43 = -0.287354499 + } else { + if (input[8]) >= (0.120836608) { + if (input[5]) >= (0.685000002) { + var43 = -0.452988923 + } else { + var43 = 0.0968504846 + } + } else { + if (input[0]) >= (0.075939849) { + var43 = -0.0440812036 + } else { + var43 = 0.013372059 + } + } + } + var var44 float64 + if (input[1]) >= (0.176575199) { + if (input[4]) >= (0.397058845) { + var44 = 0.254734188 + } else { + if (input[2]) >= (0.212456822) { + var44 = -0.593228817 + } else { + var44 = -0.200251624 + } + } + } else { + if (input[4]) >= (0.586134434) { + if (input[3]) >= (0.111825317) { + var44 = 0.247283205 + } else { + var44 = -0.212081224 + } + } else { + if (input[3]) >= (0.0226037558) { + var44 = 0.0536214635 + } else { + var44 = -0.00735966256 + } + } + } + var var45 float64 + if (input[9]) >= (0.0657032281) { + if (input[0]) >= (0.00766917318) { + if (input[8]) >= (0.0152766854) { + var45 = -0.0435701497 + } else { + var45 = -0.231140018 + } + } else { + if (input[3]) >= (0.00285463873) { + var45 = -0.0257420298 + } else { + var45 = 0.165478796 + } + } + } else { + if (input[0]) >= (0.0569924787) { + if (input[8]) >= (0.022619985) { + var45 = -0.0350094102 + } else { + var45 = 0.432442248 + } + } else { + if (input[8]) >= (0.0450432748) { + var45 = 0.204315975 + } else { + var45 = 0.00848712306 + } + } + } + var var46 float64 + if (input[8]) >= (0.0685156062) { + if (input[5]) >= (0.0350000001) { + if (input[3]) >= (0.00615793606) { + var46 = -0.00547375996 + } else { + var46 = -0.205405518 + } + } else { + if (input[3]) >= (0.0226027388) { + var46 = 0.181025118 + } else { + var46 = 0.00534206163 + } + } + } else { + if (input[5]) >= (0.114999995) { + if (input[8]) >= (0.0342905857) { + var46 = 0.0135424864 + } else { + var46 = 0.274831563 + } + } else { + if (input[8]) >= (0.0626147389) { + var46 = -0.164425164 + } else { + var46 = -0.00842097308 + } + } + } + var var47 float64 + if (input[4]) >= (0.0161064435) { + if (input[2]) >= (0.333559692) { + if (input[4]) >= (0.198179275) { + var47 = -0.100290649 + } else { + var47 = -0.755023658 + } + } else { + if (input[5]) >= (0.234999999) { + var47 = 0.109863274 + } else { + var47 = 0.00200071977 + } + } + } else { + if (input[8]) >= (0.0379622355) { + if (input[5]) >= (0.340000004) { + var47 = 0.0225960389 + } else { + var47 = -0.691998363 + } + } else { + if (input[5]) >= (0.0949999988) { + var47 = 0.232441589 + } else { + var47 = -0.14310658 + } + } + } + var var48 float64 + if (input[0]) >= (0.0278195478) { + if (input[8]) >= (0.0337660648) { + if (input[0]) >= (0.0509774461) { + var48 = -0.0114587294 + } else { + var48 = 0.1420331 + } + } else { + if (input[0]) >= (0.0738345832) { + var48 = 0.173401624 + } else { + var48 = -0.131375387 + } + } + } else { + if (input[8]) >= (0.0256359819) { + if (input[0]) >= (0.0139849624) { + var48 = 0.252238214 + } else { + var48 = 0.0486185215 + } + } else { + if (input[0]) >= (0.0212030075) { + var48 = -0.178774327 + } else { + var48 = 0.0158827659 + } + } + } + var var49 float64 + if (input[7]) >= (0.00118679181) { + if (input[4]) >= (0.360644281) { + if (input[5]) >= (0.375) { + var49 = -0.901833355 + } else { + var49 = -0.0578524359 + } + } else { + if (input[2]) >= (0.00237438967) { + var49 = 0.021668978 + } else { + var49 = 0.222485527 + } + } + } else { + if (input[8]) >= (0.0311434567) { + if (input[5]) >= (0.0149999997) { + var49 = -0.0942836106 + } else { + var49 = 0.0964765921 + } + } else { + if (input[5]) >= (0.0649999976) { + var49 = 0.185189947 + } else { + var49 = -0.0803708211 + } + } + } + var var50 float64 + if (input[0]) >= (0.00436090212) { + if (input[9]) >= (0.233895421) { + if (input[0]) >= (0.0100751882) { + var50 = -0.335006416 + } else { + var50 = -0.0961027741 + } + } else { + if (input[8]) >= (0.00911355857) { + var50 = -0.00283080316 + } else { + var50 = 0.205673814 + } + } + } else { + if (input[8]) >= (0.0116050355) { + if (input[0]) >= (0.00135338353) { + var50 = 0.185261995 + } else { + var50 = -0.438791841 + } + } else { + if (input[0]) >= (0.00105263153) { + var50 = -0.0627073348 + } else { + var50 = 0.119181477 + } + } + } + var var51 float64 + if (input[5]) >= (0.0249999985) { + if (input[0]) >= (0.039849624) { + if (input[0]) >= (0.119849622) { + var51 = -0.0243600179 + } else { + var51 = -0.217614174 + } + } else { + if (input[5]) >= (0.0949999988) { + var51 = 0.258749306 + } else { + var51 = 0.0542611703 + } + } + } else { + if (input[4]) >= (0.0161064435) { + if (input[3]) >= (0.00302164629) { + var51 = 0.00341847376 + } else { + var51 = 0.07880757 + } + } else { + if (input[0]) >= (0.00496240612) { + var51 = -0.319318205 + } else { + var51 = -0.0421217196 + } + } + } + var var52 float64 + if (input[4]) >= (0.685574234) { + if (input[3]) >= (0.177440822) { + var52 = -0.0603435449 + } else { + var52 = -0.306178689 + } + } else { + if (input[3]) >= (0.0634909272) { + if (input[4]) >= (0.0987394974) { + var52 = 0.13219589 + } else { + var52 = -0.182864487 + } + } else { + if (input[6]) >= (0.206400335) { + var52 = -0.471036732 + } else { + var52 = -0.00148937979 + } + } + } + var var53 float64 + if (input[8]) >= (0.0773013383) { + if (input[5]) >= (0.0649999976) { + if (input[3]) >= (0.00623038225) { + var53 = 0.00483682379 + } else { + var53 = -0.179307953 + } + } else { + if (input[7]) >= (0.00320988474) { + var53 = 0.0471738987 + } else { + var53 = 0.156259224 + } + } + } else { + if (input[7]) >= (0.0931315571) { + if (input[8]) >= (0.0624180436) { + var53 = -0.020441629 + } else { + var53 = -0.255031854 + } + } else { + if (input[7]) >= (0.000281814777) { + var53 = 0.00141502626 + } else { + var53 = -0.053272482 + } + } + } + var var54 float64 + if (input[1]) >= (0.162347555) { + if (input[0]) >= (0.124360904) { + if (input[0]) >= (0.165263146) { + var54 = 0.356097758 + } else { + var54 = 0.0349060223 + } + } else { + if (input[8]) >= (0.125295043) { + var54 = -0.83570987 + } else { + var54 = -0.172690049 + } + } + } else { + if (input[0]) >= (0.286466181) { + var54 = -0.289608032 + } else { + if (input[0]) >= (0.273834586) { + var54 = 0.350739658 + } else { + var54 = 0.00390034379 + } + } + } + var var55 float64 + if (input[0]) >= (0.00285714283) { + if (input[4]) >= (0.021708684) { + if (input[0]) >= (0.0145864664) { + var55 = -0.00855578016 + } else { + var55 = 0.0437418893 + } + } else { + if (input[8]) >= (0.0116050355) { + var55 = -0.0150791267 + } else { + var55 = -0.28798458 + } + } + } else { + if (input[8]) >= (0.00924468972) { + if (input[4]) >= (0.0882352963) { + var55 = -0.390152603 + } else { + var55 = 0.213675484 + } + } else { + if (input[8]) >= (0.00845790748) { + var55 = -0.390442103 + } else { + var55 = -0.0780192837 + } + } + } + var var56 float64 + if (input[6]) >= (0.0212090202) { + if (input[8]) >= (0.0458300561) { + if (input[4]) >= (0.164565831) { + var56 = -0.0577122159 + } else { + var56 = 0.171905577 + } + } else { + if (input[4]) >= (0.240196079) { + var56 = 0.129441619 + } else { + var56 = -0.0970272273 + } + } + } else { + if (input[0]) >= (0.0882706791) { + if (input[4]) >= (0.0245098043) { + var56 = -0.0160587989 + } else { + var56 = -0.373520195 + } + } else { + if (input[4]) >= (0.264005601) { + var56 = 0.140205145 + } else { + var56 = 0.00363377784 + } + } + } + var var57 float64 + if (input[6]) >= (0.00197188184) { + if (input[4]) >= (0.174369752) { + if (input[0]) >= (0.0206015036) { + var57 = -0.0363936834 + } else { + var57 = 0.163100794 + } + } else { + if (input[2]) >= (0.0099630272) { + var57 = 0.0490520671 + } else { + var57 = -0.0121400943 + } + } + } else { + if (input[4]) >= (0.0245098043) { + if (input[5]) >= (0.00499999989) { + var57 = -0.124995105 + } else { + var57 = 0.000665210711 + } + } else { + if (input[5]) >= (0.00499999989) { + var57 = 0.0405129232 + } else { + var57 = -0.237474099 + } + } + } + var var58 float64 + if (input[9]) >= (0.0657032281) { + if (input[5]) >= (0.0949999988) { + if (input[8]) >= (0.0379622355) { + var58 = -0.0863649622 + } else { + var58 = 0.28073594 + } + } else { + if (input[6]) >= (0.00519312406) { + var58 = -0.061413832 + } else { + var58 = 0.00650844676 + } + } + } else { + if (input[5]) >= (0.0249999985) { + if (input[3]) >= (0.00454632333) { + var58 = 0.00568365026 + } else { + var58 = -0.156469226 + } + } else { + if (input[7]) >= (0.0112215932) { + var58 = 0.0680932105 + } else { + var58 = 0.00331812678 + } + } + } + var var59 float64 + if (input[5]) >= (0.185000002) { + if (input[4]) >= (0.320028007) { + if (input[5]) >= (0.340000004) { + var59 = -0.751533031 + } else { + var59 = -0.0821505114 + } + } else { + if (input[0]) >= (0.171278208) { + var59 = -0.132254183 + } else { + var59 = 0.176801816 + } + } + } else { + if (input[4]) >= (0.0063025211) { + if (input[4]) >= (0.0119047621) { + var59 = -0.00440405589 + } else { + var59 = -0.148658827 + } + } else { + if (input[4]) >= (0.00490196096) { + var59 = 0.140768483 + } else { + var59 = 0.350664854 + } + } + } + var var60 float64 + if (input[1]) >= (0.0429369919) { + if (input[1]) >= (0.0480182916) { + if (input[9]) >= (0.116594002) { + var60 = -0.102537565 + } else { + var60 = 0.0120711168 + } + } else { + if (input[5]) >= (0.0149999997) { + var60 = 0.0871903747 + } else { + var60 = -0.12257605 + } + } + } else { + if (input[3]) >= (0.0065933764) { + if (input[0]) >= (0.121654138) { + var60 = -0.0304677356 + } else { + var60 = 0.0676648691 + } + } else { + if (input[0]) >= (0.00105263153) { + var60 = -0.0110558337 + } else { + var60 = 0.182563081 + } + } + } + var var61 float64 + if (input[0]) >= (0.00827067718) { + if (input[2]) >= (0.0072721187) { + if (input[4]) >= (0.174369752) { + var61 = -0.0175676141 + } else { + var61 = 0.0212861542 + } + } else { + if (input[1]) >= (0.0297256093) { + var61 = -0.157087296 + } else { + var61 = 0.0397030264 + } + } + } else { + if (input[0]) >= (0.00706766918) { + if (input[4]) >= (0.0175070036) { + var61 = 0.29746896 + } else { + var61 = -0.215615198 + } + } else { + if (input[4]) >= (0.0231092442) { + var61 = -0.0457295962 + } else { + var61 = 0.0742075741 + } + } + } + var var62 float64 + if (input[8]) >= (0.148373991) { + if (input[5]) >= (0.305000007) { + if (input[4]) >= (0.30252102) { + var62 = -0.431491196 + } else { + var62 = 0.0481870845 + } + } else { + if (input[4]) >= (0.184173673) { + var62 = 0.243601143 + } else { + var62 = -0.123877004 + } + } + } else { + if (input[5]) >= (0.284999996) { + if (input[5]) >= (0.625) { + var62 = -0.200812891 + } else { + var62 = 0.192099884 + } + } else { + if (input[5]) >= (0.0249999985) { + var62 = -0.0416302495 + } else { + var62 = 0.00593543472 + } + } + } + var var63 float64 + if (input[4]) >= (0.65196079) { + if (input[3]) >= (0.161528066) { + if (input[4]) >= (0.707983196) { + var63 = -0.0899664462 + } else { + var63 = 0.322766781 + } + } else { + if (input[8]) >= (0.0527144) { + var63 = -0.293584853 + } else { + var63 = 0.187979877 + } + } + } else { + if (input[8]) >= (0.0961841047) { + if (input[0]) >= (0.156842113) { + var63 = -0.106119491 + } else { + var63 = 0.125702992 + } + } else { + if (input[0]) >= (0.0350375921) { + var63 = -0.0268263798 + } else { + var63 = 0.0142555572 + } + } + } + var var64 float64 + if (input[0]) >= (0.000150375941) { + if (input[0]) >= (0.00105263153) { + if (input[2]) >= (0.00161722768) { + var64 = 0.00111045409 + } else { + var64 = -0.0768416822 + } + } else { + if (input[4]) >= (0.0224089641) { + var64 = -0.0887310654 + } else { + var64 = 0.300011128 + } + } + } else { + var64 = -0.390776604 + } + var var65 float64 + if (input[3]) >= (0.00207781093) { + if (input[7]) >= (0.439143658) { + var65 = -0.464211673 + } else { + if (input[3]) >= (0.00241563935) { + var65 = 0.000459081435 + } else { + var65 = -0.119567484 + } + } + } else { + if (input[0]) >= (0.00917293224) { + if (input[7]) >= (0.00857554097) { + var65 = 0.192073569 + } else { + var65 = -0.210251316 + } + } else { + if (input[1]) >= (0.0205792673) { + var65 = 0.123285308 + } else { + var65 = 0.321597934 + } + } + } + var var66 float64 + if (input[0]) >= (0.286466181) { + var66 = -0.282670498 + } else { + if (input[0]) >= (0.000150375941) { + if (input[0]) >= (0.00766917318) { + var66 = -0.00459707389 + } else { + var66 = 0.0313954577 + } + } else { + var66 = -0.338898867 + } + } + var var67 float64 + if (input[5]) >= (0.784999967) { + if (input[9]) >= (0.0237057135) { + var67 = 0.0696140826 + } else { + if (input[2]) >= (0.0803144276) { + var67 = -0.425103754 + } else { + var67 = -0.174536571 + } + } + } else { + if (input[9]) >= (0.0238933973) { + if (input[5]) >= (0.284999996) { + var67 = 0.214611426 + } else { + var67 = -0.0105478894 + } + } else { + if (input[0]) >= (0.0756390989) { + var67 = -0.00446681352 + } else { + var67 = 0.0521040969 + } + } + } + var var68 float64 + if (input[8]) >= (0.00793338567) { + if (input[8]) >= (0.0135719907) { + if (input[0]) >= (0.00496240612) { + var68 = -9.80415571e-05 + } else { + var68 = 0.191178605 + } + } else { + if (input[4]) >= (0.0371148475) { + var68 = -0.246011645 + } else { + var68 = 0.00743888691 + } + } + } else { + if (input[4]) >= (0.0315126069) { + if (input[4]) >= (0.138655469) { + var68 = 0.281557769 + } else { + var68 = -0.339205354 + } + } else { + if (input[6]) >= (0.0023632478) { + var68 = 0.344240695 + } else { + var68 = -0.0382838994 + } + } + } + var var69 float64 + if (input[8]) >= (0.0685156062) { + if (input[0]) >= (0.121954888) { + if (input[2]) >= (0.0860618129) { + var69 = 0.0945601761 + } else { + var69 = -0.0943377987 + } + } else { + if (input[0]) >= (0.119849622) { + var69 = 0.305908203 + } else { + var69 = 0.00725052459 + } + } + } else { + if (input[0]) >= (0.194135338) { + if (input[8]) >= (0.0557959601) { + var69 = 0.0243753754 + } else { + var69 = 0.450308442 + } + } else { + if (input[0]) >= (0.107218042) { + var69 = -0.120318107 + } else { + var69 = -0.000368774345 + } + } + } + var var70 float64 + if (input[6]) >= (0.189089924) { + if (input[4]) >= (0.30112046) { + var70 = -0.0039761723 + } else { + if (input[3]) >= (0.00329338363) { + var70 = -0.483454973 + } else { + var70 = -0.0453006402 + } + } + } else { + if (input[4]) >= (0.685574234) { + if (input[3]) >= (0.1855205) { + var70 = -0.0268479586 + } else { + var70 = -0.293679446 + } + } else { + if (input[8]) >= (0.148373991) { + var70 = 0.0855231434 + } else { + var70 = 0.000505772943 + } + } + } + var var71 float64 + if (input[4]) >= (0.0245098043) { + if (input[4]) >= (0.032913167) { + if (input[8]) >= (0.0138342511) { + var71 = 0.00857743714 + } else { + var71 = -0.168726325 + } + } else { + if (input[0]) >= (0.0365413539) { + var71 = 0.334990561 + } else { + var71 = 0.0487056337 + } + } + } else { + if (input[4]) >= (0.0231092442) { + if (input[0]) >= (0.00736842118) { + var71 = 0.0473516211 + } else { + var71 = -0.35587132 + } + } else { + if (input[0]) >= (0.0485714301) { + var71 = -0.304941654 + } else { + var71 = 0.0247289594 + } + } + } + var var72 float64 + if (input[4]) >= (0.685574234) { + var72 = -0.276174217 + } else { + if (input[8]) >= (0.0833333358) { + if (input[4]) >= (0.493697464) { + var72 = -0.111761406 + } else { + var72 = 0.0561834164 + } + } else { + if (input[4]) >= (0.0665266141) { + var72 = -0.0197163373 + } else { + var72 = 0.0120168198 + } + } + } + var var73 float64 + if (input[1]) >= (0.223577231) { + if (input[5]) >= (0.204999998) { + var73 = 0.303820401 + } else { + if (input[2]) >= (0.0377650075) { + var73 = -0.322835207 + } else { + var73 = 0.137270167 + } + } + } else { + if (input[4]) >= (0.0259103645) { + if (input[8]) >= (0.00937581994) { + var73 = 0.00198190333 + } else { + var73 = 0.240280673 + } + } else { + if (input[5]) >= (0.00499999989) { + var73 = 0.0547016338 + } else { + var73 = -0.0707016587 + } + } + } + var var74 float64 + if (input[5]) >= (0.0249999985) { + if (input[4]) >= (0.188375354) { + if (input[0]) >= (0.12045113) { + var74 = -0.0145008247 + } else { + var74 = -0.508666456 + } + } else { + if (input[2]) >= (0.247245029) { + var74 = -0.503781438 + } else { + var74 = 0.0430011936 + } + } + } else { + if (input[4]) >= (0.188375354) { + if (input[0]) >= (0.0801503733) { + var74 = -0.0366654098 + } else { + var74 = 0.0991560444 + } + } else { + if (input[0]) >= (0.12736842) { + var74 = 0.134874642 + } else { + var74 = -0.0140978368 + } + } + } + var var75 float64 + if (input[0]) >= (0.00315789459) { + if (input[4]) >= (0.0189075638) { + if (input[8]) >= (0.00924468972) { + var75 = -0.000224242816 + } else { + var75 = 0.170978561 + } + } else { + if (input[8]) >= (0.0131786) { + var75 = -0.0400259048 + } else { + var75 = -0.274014562 + } + } + } else { + if (input[8]) >= (0.00911355857) { + if (input[4]) >= (0.0882352963) { + var75 = -0.240306228 + } else { + var75 = 0.162668601 + } + } else { + if (input[8]) >= (0.00845790748) { + var75 = -0.375939935 + } else { + var75 = -0.0707179159 + } + } + } + var var76 float64 + if (input[0]) >= (0.286466181) { + var76 = -0.280112207 + } else { + if (input[4]) >= (0.00350140082) { + if (input[4]) >= (0.0119047621) { + var76 = 0.00230477797 + } else { + var76 = -0.152240932 + } + } else { + if (input[5]) >= (0.784999967) { + var76 = -0.234420657 + } else { + var76 = 0.279333055 + } + } + } + var var77 float64 + if (input[0]) >= (0.00796992518) { + if (input[8]) >= (0.0151455551) { + if (input[0]) >= (0.0221052617) { + var77 = -0.0120887421 + } else { + var77 = 0.0372003168 + } + } else { + if (input[1]) >= (0.0734247938) { + var77 = 0.0372776501 + } else { + var77 = -0.220527187 + } + } + } else { + if (input[8]) >= (0.0349462368) { + if (input[0]) >= (0.00526315812) { + var77 = -1.15129054 + } else { + var77 = 0.132991552 + } + } else { + if (input[7]) >= (0.000921434839) { + var77 = 0.0847387537 + } else { + var77 = -0.0179769937 + } + } + } + var var78 float64 + if (input[8]) >= (0.00150799891) { + if (input[2]) >= (0.475341976) { + if (input[4]) >= (0.406862736) { + var78 = -0.166963786 + } else { + var78 = -0.499946982 + } + } else { + if (input[1]) >= (0.0439532511) { + var78 = -0.020062875 + } else { + var78 = 0.00789602194 + } + } + } else { + var78 = 0.572091877 + } + var var79 float64 + if (input[3]) >= (0.00207781093) { + if (input[6]) >= (0.0945299119) { + if (input[9]) >= (0.0206017382) { + var79 = -0.0459142439 + } else { + var79 = -0.235742286 + } + } else { + if (input[3]) >= (0.114606753) { + var79 = 0.115663275 + } else { + var79 = -0.000967400323 + } + } + } else { + if (input[1]) >= (0.0210873988) { + if (input[2]) >= (0.00300962897) { + var79 = -0.19450447 + } else { + var79 = 0.150479212 + } + } else { + if (input[6]) >= (0.062543273) { + var79 = 0.0757033601 + } else { + var79 = 0.327922523 + } + } + } + var var80 float64 + if (input[0]) >= (0.159248114) { + if (input[8]) >= (0.0597298704) { + if (input[8]) >= (0.166601107) { + var80 = 0.107864425 + } else { + var80 = -0.164368838 + } + } else { + if (input[1]) >= (0.0134654474) { + var80 = -0.055564899 + } else { + var80 = 0.305301607 + } + } + } else { + if (input[8]) >= (0.0677288249) { + if (input[0]) >= (0.121654138) { + var80 = -0.00632492779 + } else { + var80 = 0.093042016 + } + } else { + if (input[0]) >= (0.0672180429) { + var80 = -0.0701212659 + } else { + var80 = 0.00240272097 + } + } + } + var var81 float64 + if (input[4]) >= (0.125350147) { + if (input[8]) >= (0.0256359819) { + if (input[4]) >= (0.156162471) { + var81 = -0.0260594562 + } else { + var81 = 0.118602015 + } + } else { + if (input[1]) >= (0.0292174798) { + var81 = 0.0459964201 + } else { + var81 = 0.226418257 + } + } + } else { + if (input[8]) >= (0.0261605028) { + if (input[8]) >= (0.107854709) { + var81 = -0.166503102 + } else { + var81 = 0.0645119846 + } + } else { + if (input[4]) >= (0.0665266141) { + var81 = -0.186870784 + } else { + var81 = -0.00211787899 + } + } + } + var var82 float64 + if (input[9]) >= (0.0257124715) { + if (input[1]) >= (0.014989838) { + if (input[4]) >= (0.0077030817) { + var82 = -0.0054807961 + } else { + var82 = 0.261680484 + } + } else { + if (input[4]) >= (0.164565831) { + var82 = -0.245189562 + } else { + var82 = -0.0199352447 + } + } + } else { + if (input[4]) >= (0.416666687) { + if (input[5]) >= (0.114999995) { + var82 = -0.285777807 + } else { + var82 = 0.0128018437 + } + } else { + if (input[1]) >= (0.117123984) { + var82 = -0.0802750587 + } else { + var82 = 0.0350131691 + } + } + } + var var83 float64 + if (input[8]) >= (0.0458300561) { + if (input[0]) >= (0.0590977445) { + if (input[8]) >= (0.0685156062) { + var83 = 0.0217146017 + } else { + var83 = -0.063220486 + } + } else { + if (input[8]) >= (0.111067399) { + var83 = -0.273925871 + } else { + var83 = 0.158429176 + } + } + } else { + if (input[1]) >= (0.0129573178) { + if (input[5]) >= (0.114999995) { + var83 = 0.151839375 + } else { + var83 = -0.00610355008 + } + } else { + if (input[9]) >= (0.0430803001) { + var83 = -0.399477869 + } else { + var83 = -0.0923261866 + } + } + } + var var84 float64 + if (input[8]) >= (0.100118019) { + if (input[5]) >= (0.63499999) { + if (input[3]) >= (0.138229847) { + var84 = -0.00873858109 + } else { + var84 = -0.448209196 + } + } else { + if (input[3]) >= (0.00651635462) { + var84 = 0.0717797875 + } else { + var84 = -0.0482409187 + } + } + } else { + if (input[5]) >= (0.305000007) { + if (input[7]) >= (0.229440123) { + var84 = -0.342827976 + } else { + var84 = 0.201320991 + } + } else { + if (input[5]) >= (0.0249999985) { + var84 = -0.0364255831 + } else { + var84 = 0.00283409888 + } + } + } + var var85 float64 + if (input[6]) >= (0.0678417683) { + if (input[0]) >= (0.115639098) { + if (input[0]) >= (0.130676687) { + var85 = -0.150669739 + } else { + var85 = 0.217826098 + } + } else { + if (input[8]) >= (0.0329792798) { + var85 = -0.238209143 + } else { + var85 = -0.0208676402 + } + } + } else { + if (input[0]) >= (0.0281203017) { + if (input[8]) >= (0.03311041) { + var85 = 0.00799535215 + } else { + var85 = -0.0613433234 + } + } else { + if (input[8]) >= (0.0261605028) { + var85 = 0.134910792 + } else { + var85 = 0.000760196883 + } + } + } + var var86 float64 + if (input[3]) >= (0.00297944969) { + if (input[9]) >= (0.156599194) { + if (input[4]) >= (0.0203081239) { + var86 = -0.123827316 + } else { + var86 = 0.0579396524 + } + } else { + if (input[1]) >= (0.111534551) { + var86 = -0.055729609 + } else { + var86 = 0.000652362942 + } + } + } else { + if (input[5]) >= (0.0350000001) { + if (input[5]) >= (0.114999995) { + var86 = 0.122355014 + } else { + var86 = -0.186418205 + } + } else { + if (input[8]) >= (0.0168502498) { + var86 = 0.144800797 + } else { + var86 = 0.014749934 + } + } + } + var var87 float64 + if (input[7]) >= (0.423489422) { + var87 = -0.406787097 + } else { + if (input[4]) >= (0.0119047621) { + if (input[3]) >= (0.300652921) { + var87 = -0.482897073 + } else { + var87 = 0.00436963933 + } + } else { + if (input[8]) >= (0.0108182533) { + var87 = -0.116776653 + } else { + var87 = 0.246469855 + } + } + } + var var88 float64 + if (input[0]) >= (0.00105263153) { + if (input[0]) >= (0.00195488706) { + if (input[0]) >= (0.00255639106) { + var88 = -0.00143280486 + } else { + var88 = 0.158687294 + } + } else { + if (input[3]) >= (0.00449090824) { + var88 = 0.0765692219 + } else { + var88 = -0.223963976 + } + } + } else { + if (input[4]) >= (0.0287114866) { + var88 = 0.365044773 + } else { + if (input[4]) >= (0.0224089641) { + var88 = -0.323876649 + } else { + var88 = 0.188858822 + } + } + } + var var89 float64 + if (input[6]) >= (0.00118915015) { + if (input[3]) >= (0.00298046647) { + if (input[3]) >= (0.00418993831) { + var89 = 0.00635303184 + } else { + var89 = -0.0314252861 + } + } else { + if (input[6]) >= (0.011605503) { + var89 = -0.0445525944 + } else { + var89 = 0.063242346 + } + } + } else { + if (input[7]) >= (0.000143447192) { + if (input[2]) >= (0.0184177347) { + var89 = -0.00925727002 + } else { + var89 = -0.213141814 + } + } else { + var89 = 0.102692276 + } + } + var var90 float64 + if (input[0]) >= (0.00827067718) { + if (input[9]) >= (0.17593047) { + if (input[5]) >= (0.0249999985) { + var90 = 0.343772948 + } else { + var90 = -0.221835926 + } + } else { + if (input[2]) >= (0.00744489254) { + var90 = 0.00403431011 + } else { + var90 = -0.0375701189 + } + } + } else { + if (input[0]) >= (0.00706766918) { + if (input[5]) >= (0.00499999989) { + var90 = 0.2627922 + } else { + var90 = 0.0111245057 + } + } else { + if (input[5]) >= (0.0850000009) { + var90 = -0.336912066 + } else { + var90 = 0.0100989277 + } + } + } + var var91 float64 + if (input[8]) >= (0.00976921059) { + if (input[8]) >= (0.0102937315) { + if (input[9]) >= (0.161854297) { + var91 = -0.0537579805 + } else { + var91 = 0.00243335939 + } + } else { + if (input[6]) >= (0.00347713521) { + var91 = 0.0283897799 + } else { + var91 = 0.216859028 + } + } + } else { + if (input[5]) >= (0.00499999989) { + var91 = -0.459523469 + } else { + if (input[7]) >= (0.000554689555) { + var91 = 0.075264141 + } else { + var91 = -0.137274683 + } + } + } + var var92 float64 + if (input[1]) >= (0.320121944) { + if (input[9]) >= (0.00281523401) { + var92 = -0.466544241 + } else { + var92 = -0.0629050136 + } + } else { + if (input[4]) >= (0.685574234) { + if (input[2]) >= (0.185972571) { + var92 = -0.0635989532 + } else { + var92 = -0.285467863 + } + } else { + if (input[4]) >= (0.212184876) { + var92 = -0.0161312371 + } else { + var92 = 0.00648842193 + } + } + } + var var93 float64 + if (input[7]) >= (0.26622498) { + if (input[5]) >= (0.0199999996) { + if (input[0]) >= (0.128571421) { + var93 = -0.170514435 + } else { + var93 = -0.467014045 + } + } else { + if (input[0]) >= (0.131879702) { + var93 = -0.279649943 + } else { + var93 = 0.163631767 + } + } + } else { + if (input[2]) >= (0.203194901) { + if (input[2]) >= (0.23077184) { + var93 = 0.00896277651 + } else { + var93 = 0.250300944 + } + } else { + if (input[0]) >= (0.000150375941) { + var93 = -0.000812978891 + } else { + var93 = -0.320379227 + } + } + } + var var94 float64 + if (input[3]) >= (0.121799268) { + if (input[9]) >= (0.00931192748) { + var94 = 0.39591974 + } else { + if (input[1]) >= (0.210365862) { + var94 = -0.108574733 + } else { + var94 = 0.154940248 + } + } + } else { + if (input[9]) >= (0.716412067) { + if (input[7]) >= (0.00228113541) { + var94 = 0.333740085 + } else { + var94 = 0.00728256721 + } + } else { + if (input[8]) >= (0.00426173629) { + var94 = -0.00433406373 + } else { + var94 = 0.252547026 + } + } + } + var var95 float64 + if (input[4]) >= (0.00350140082) { + if (input[4]) >= (0.0161064435) { + if (input[5]) >= (0.685000002) { + var95 = -0.233180091 + } else { + var95 = 0.00114596763 + } + } else { + if (input[5]) >= (0.145000011) { + var95 = -0.389273703 + } else { + var95 = -0.0317125656 + } + } + } else { + if (input[7]) >= (0.195825323) { + var95 = -0.245654166 + } else { + if (input[5]) >= (0.784999967) { + var95 = 0.00872725714 + } else { + var95 = 0.297403693 + } + } + } + var var96 float64 + if (input[0]) >= (0.00105263153) { + if (input[5]) >= (0.114999995) { + if (input[0]) >= (0.0741353408) { + var96 = -0.010054796 + } else { + var96 = 0.188875318 + } + } else { + if (input[4]) >= (0.0077030817) { + var96 = -0.00601599552 + } else { + var96 = 0.299144506 + } + } + } else { + if (input[8]) >= (0.00937581994) { + if (input[0]) >= (0.000751879707) { + var96 = -0.0229117479 + } else { + var96 = 0.320491403 + } + } else { + if (input[4]) >= (0.0196078438) { + var96 = 0.127602771 + } else { + var96 = -0.395168841 + } + } + } + var var97 float64 + if (input[0]) >= (0.286466181) { + var97 = -0.271149933 + } else { + if (input[2]) >= (0.003614838) { + if (input[0]) >= (0.00436090212) { + var97 = 0.000261748384 + } else { + var97 = 0.0781365782 + } + } else { + if (input[0]) >= (0.00616541365) { + var97 = -0.0698476136 + } else { + var97 = -0.00467303721 + } + } + } + var var98 float64 + if (input[7]) >= (2.98678988e-05) { + if (input[4]) >= (0.0245098043) { + if (input[0]) >= (0.0175939836) { + var98 = -0.00519643258 + } else { + var98 = 0.0361424163 + } + } else { + if (input[4]) >= (0.0231092442) { + var98 = -0.234900132 + } else { + var98 = -0.00274063158 + } + } + } else { + if (input[0]) >= (0.0198496245) { + var98 = -0.280595928 + } else { + if (input[0]) >= (0.00315789459) { + var98 = 0.388148874 + } else { + var98 = 0.0318337381 + } + } + } + var var99 float64 + if (input[4]) >= (0.12114846) { + if (input[0]) >= (0.0196992494) { + if (input[4]) >= (0.133753508) { + var99 = -0.00308614224 + } else { + var99 = 0.121284604 + } + } else { + if (input[8]) >= (0.0140965115) { + var99 = 0.189820156 + } else { + var99 = -0.194369376 + } + } + } else { + if (input[8]) >= (0.048977185) { + if (input[4]) >= (0.0497198887) { + var99 = 0.14546074 + } else { + var99 = -0.0577622503 + } + } else { + if (input[0]) >= (0.0377443582) { + var99 = -0.155487567 + } else { + var99 = -0.0057259351 + } + } + } + var var100 float64 + if (input[0]) >= (0.162255645) { + if (input[8]) >= (0.0576317869) { + if (input[4]) >= (0.398459375) { + var100 = 0.20340018 + } else { + var100 = -0.150473848 + } + } else { + if (input[1]) >= (0.00990853645) { + var100 = 0.0648944527 + } else { + var100 = 0.40326184 + } + } + } else { + if (input[8]) >= (0.100118019) { + if (input[4]) >= (0.493697464) { + var100 = -0.111520477 + } else { + var100 = 0.11796052 + } + } else { + if (input[7]) >= (0.099432677) { + var100 = -0.103333659 + } else { + var100 = 0.000719776144 + } + } + } + var var101 float64 + if (input[4]) >= (0.262605071) { + if (input[0]) >= (0.0789473653) { + if (input[8]) >= (0.0670731738) { + var101 = 0.00383618264 + } else { + var101 = -0.235705093 + } + } else { + if (input[5]) >= (0.00499999989) { + var101 = -0.271310031 + } else { + var101 = 0.193909615 + } + } + } else { + if (input[4]) >= (0.212184876) { + if (input[0]) >= (0.0657142848) { + var101 = 0.0607793964 + } else { + var101 = -0.174820423 + } + } else { + if (input[8]) >= (0.0329792798) { + var101 = 0.0411589891 + } else { + var101 = -0.0213418566 + } + } + } + var var102 float64 + if (input[0]) >= (0.00345864659) { + if (input[4]) >= (0.0189075638) { + if (input[8]) >= (0.011867296) { + var102 = -0.0052998797 + } else { + var102 = 0.0461234748 + } + } else { + if (input[4]) >= (0.0147058824) { + var102 = -0.179890111 + } else { + var102 = 0.0156200761 + } + } + } else { + if (input[8]) >= (0.00950695015) { + if (input[4]) >= (0.0189075638) { + var102 = 0.020123627 + } else { + var102 = 0.207051978 + } + } else { + if (input[4]) >= (0.0301120467) { + var102 = 0.341580123 + } else { + var102 = -0.149347827 + } + } + } + var var103 float64 + if (input[0]) >= (0.00105263153) { + if (input[2]) >= (0.00161802839) { + if (input[0]) >= (0.00436090212) { + var103 = -0.00331460079 + } else { + var103 = 0.0457229242 + } + } else { + if (input[7]) >= (0.000375278993) { + var103 = 0.0939382836 + } else { + var103 = -0.120965004 + } + } + } else { + if (input[4]) >= (0.0189075638) { + if (input[4]) >= (0.0224089641) { + var103 = 0.0117833233 + } else { + var103 = 0.394975334 + } + } else { + if (input[2]) >= (0.0011069139) { + var103 = 0.0390520617 + } else { + var103 = -0.194492102 + } + } + } + var var104 float64 + if (input[6]) >= (0.176506013) { + if (input[0]) >= (0.0222556386) { + if (input[3]) >= (0.00621513044) { + var104 = -0.19416143 + } else { + var104 = 0.167571411 + } + } else { + var104 = -0.529426098 + } + } else { + if (input[3]) >= (0.00183251023) { + if (input[6]) >= (0.0211789142) { + var104 = -0.017798055 + } else { + var104 = 0.00704984041 + } + } else { + if (input[0]) >= (0.00766917318) { + var104 = 0.0607308485 + } else { + var104 = 0.304542124 + } + } + } + var var105 float64 + if (input[0]) >= (0.181804508) { + if (input[1]) >= (0.0759654492) { + if (input[4]) >= (0.179971993) { + var105 = 0.293977827 + } else { + var105 = -0.0854395628 + } + } else { + if (input[4]) >= (0.0763305351) { + var105 = -0.13126567 + } else { + var105 = 0.0135152396 + } + } + } else { + if (input[4]) >= (0.0119047621) { + if (input[6]) >= (0.203450039) { + var105 = -0.244897425 + } else { + var105 = 0.00562332664 + } + } else { + if (input[4]) >= (0.0077030817) { + var105 = -0.149814829 + } else { + var105 = 0.0688502789 + } + } + } + var var106 float64 + if (input[6]) >= (0.00185146159) { + if (input[1]) >= (0.00330284564) { + if (input[5]) >= (0.86500001) { + var106 = -0.235077411 + } else { + var106 = 0.00454800203 + } + } else { + if (input[9]) >= (0.0243265107) { + var106 = 0.060991291 + } else { + var106 = -0.277412832 + } + } + } else { + if (input[9]) >= (0.159775347) { + if (input[5]) >= (0.0350000001) { + var106 = 0.0990184322 + } else { + var106 = -0.177583158 + } + } else { + if (input[1]) >= (0.118140243) { + var106 = -0.194555029 + } else { + var106 = -0.0163350087 + } + } + } + var var107 float64 + if (input[8]) >= (0.00976921059) { + if (input[8]) >= (0.0105559928) { + if (input[4]) >= (0.0273109246) { + var107 = 0.0123843709 + } else { + var107 = -0.045518741 + } + } else { + if (input[4]) >= (0.0273109246) { + var107 = -0.245683357 + } else { + var107 = 0.210123703 + } + } + } else { + if (input[5]) >= (0.00499999989) { + var107 = -0.363547087 + } else { + if (input[4]) >= (0.0483193286) { + var107 = 0.27536726 + } else { + var107 = -0.0471846871 + } + } + } + var var108 float64 + if (input[0]) >= (0.00105263153) { + if (input[0]) >= (0.00195488706) { + if (input[0]) >= (0.00255639106) { + var108 = 8.20997375e-05 + } else { + var108 = 0.150972873 + } + } else { + if (input[4]) >= (0.0161064435) { + var108 = -0.0512363054 + } else { + var108 = -0.363469094 + } + } + } else { + if (input[4]) >= (0.0287114866) { + var108 = 0.311502278 + } else { + if (input[4]) >= (0.0224089641) { + var108 = -0.297801763 + } else { + var108 = 0.175135627 + } + } + } + var var109 float64 + if (input[3]) >= (0.00207933597) { + if (input[3]) >= (0.00241563935) { + if (input[4]) >= (0.633753538) { + var109 = -0.138077125 + } else { + var109 = 0.000789805257 + } + } else { + if (input[8]) >= (0.0160634667) { + var109 = 0.0661266297 + } else { + var109 = -0.185510427 + } + } + } else { + if (input[3]) >= (0.00138105545) { + if (input[9]) >= (0.162850469) { + var109 = 0.00529784197 + } else { + var109 = 0.251780123 + } + } else { + var109 = -0.0781100243 + } + } + var var110 float64 + if (input[0]) >= (0.286466181) { + var110 = -0.257048219 + } else { + if (input[4]) >= (0.684173703) { + if (input[3]) >= (0.182485893) { + var110 = -0.037820816 + } else { + var110 = -0.26898703 + } + } else { + if (input[7]) >= (2.98678988e-05) { + var110 = 0.00392430276 + } else { + var110 = 0.125180557 + } + } + } + var var111 float64 + if (input[8]) >= (0.148373991) { + if (input[4]) >= (0.198179275) { + if (input[5]) >= (0.405000001) { + var111 = -0.390388787 + } else { + var111 = 0.19688642 + } + } else { + if (input[3]) >= (0.0253007915) { + var111 = -0.304027438 + } else { + var111 = 0.0247479454 + } + } + } else { + if (input[5]) >= (0.275000006) { + if (input[4]) >= (0.322829127) { + var111 = -0.371938825 + } else { + var111 = 0.131871164 + } + } else { + if (input[6]) >= (0.0610380247) { + var111 = -0.0630374253 + } else { + var111 = -0.00408200454 + } + } + } + var var112 float64 + if (input[3]) >= (0.300652921) { + var112 = -0.372335076 + } else { + if (input[3]) >= (0.0223696381) { + if (input[4]) >= (0.0623249337) { + var112 = 0.0343450904 + } else { + var112 = -0.151382953 + } + } else { + if (input[4]) >= (0.212184876) { + var112 = -0.0491784625 + } else { + var112 = 0.00353563856 + } + } + } + var var113 float64 + if (input[4]) >= (0.240196079) { + if (input[1]) >= (0.03125) { + if (input[3]) >= (0.0217038952) { + var113 = 0.0171060227 + } else { + var113 = 0.137512341 + } + } else { + if (input[8]) >= (0.111132964) { + var113 = 0.0580299236 + } else { + var113 = -0.0986677334 + } + } + } else { + if (input[4]) >= (0.221988797) { + if (input[8]) >= (0.0286519807) { + var113 = -0.257346302 + } else { + var113 = 0.171087191 + } + } else { + if (input[1]) >= (0.0353150405) { + var113 = -0.0274365898 + } else { + var113 = 0.0206221379 + } + } + } + var var114 float64 + if (input[1]) >= (0.0673272386) { + if (input[4]) >= (0.143557429) { + if (input[2]) >= (0.0257102754) { + var114 = 0.0388073623 + } else { + var114 = 0.180818915 + } + } else { + if (input[4]) >= (0.0231092442) { + var114 = -0.0400297865 + } else { + var114 = 0.0899960995 + } + } + } else { + if (input[4]) >= (0.574929953) { + if (input[3]) >= (0.0224926714) { + var114 = -0.230021387 + } else { + var114 = 0.162359819 + } + } else { + if (input[3]) >= (0.0223861635) { + var114 = 0.029477017 + } else { + var114 = -0.0116269495 + } + } + } + var var115 float64 + if (input[0]) >= (0.0804511309) { + if (input[8]) >= (0.0245869402) { + if (input[0]) >= (0.119849622) { + var115 = 1.70739952e-06 + } else { + var115 = -0.134306028 + } + } else { + if (input[0]) >= (0.106917292) { + var115 = -0.226166919 + } else { + var115 = 0.364914417 + } + } + } else { + if (input[8]) >= (0.0586808287) { + if (input[2]) >= (0.130370602) { + var115 = -0.200198486 + } else { + var115 = 0.15689221 + } + } else { + if (input[7]) >= (0.0777881965) { + var115 = -0.22090514 + } else { + var115 = 0.00376549247 + } + } + } + var var116 float64 + if (input[0]) >= (0.00796992518) { + if (input[8]) >= (0.0151455551) { + if (input[0]) >= (0.0350375921) { + var116 = -0.0086769145 + } else { + var116 = 0.0190493837 + } + } else { + if (input[2]) >= (0.0187338553) { + var116 = 0.161135659 + } else { + var116 = -0.177371174 + } + } + } else { + if (input[5]) >= (0.0149999997) { + if (input[5]) >= (0.0450000018) { + var116 = -0.0829395279 + } else { + var116 = 0.288338065 + } + } else { + if (input[2]) >= (0.0214403775) { + var116 = -0.331983596 + } else { + var116 = 0.00266320258 + } + } + } + var var117 float64 + if (input[4]) >= (0.712184906) { + var117 = -0.275763988 + } else { + if (input[8]) >= (0.00150799891) { + if (input[3]) >= (0.121799268) { + var117 = 0.100804955 + } else { + var117 = 3.66393251e-05 + } + } else { + var117 = 0.336973011 + } + } + var var118 float64 + if (input[7]) >= (0.0124138705) { + if (input[4]) >= (0.415266097) { + if (input[2]) >= (0.111952268) { + var118 = 0.112126507 + } else { + var118 = -0.160864264 + } + } else { + if (input[4]) >= (0.0553221293) { + var118 = 0.0382908694 + } else { + var118 = -0.0283828937 + } + } + } else { + if (input[4]) >= (0.472689092) { + if (input[5]) >= (0.0450000018) { + var118 = -0.213127285 + } else { + var118 = 0.26966086 + } + } else { + if (input[4]) >= (0.0665266141) { + var118 = -0.0276819896 + } else { + var118 = 0.0197456609 + } + } + } + var var119 float64 + if (input[9]) >= (0.254843652) { + if (input[0]) >= (0.00616541365) { + if (input[9]) >= (0.281725526) { + var119 = -0.285425395 + } else { + var119 = -0.0482162274 + } + } else { + if (input[1]) >= (0.0485264212) { + var119 = -0.168016255 + } else { + var119 = 0.0479509942 + } + } + } else { + if (input[7]) >= (2.98678988e-05) { + if (input[0]) >= (0.158646613) { + var119 = -0.035405986 + } else { + var119 = 0.0027063298 + } + } else { + if (input[4]) >= (0.0231092442) { + var119 = 0.00618083728 + } else { + var119 = 0.254611731 + } + } + } + var var120 float64 + if (input[1]) >= (0.103912599) { + if (input[0]) >= (0.12045113) { + if (input[5]) >= (0.175000012) { + var120 = -0.117579542 + } else { + var120 = 0.141733766 + } + } else { + if (input[8]) >= (0.0109493835) { + var120 = -0.0944417119 + } else { + var120 = 0.0431197174 + } + } + } else { + if (input[0]) >= (0.121654138) { + if (input[1]) >= (0.014989838) { + var120 = -0.058864858 + } else { + var120 = 0.0610758811 + } + } else { + if (input[0]) >= (0.12045113) { + var120 = 0.132870913 + } else { + var120 = 0.00166407996 + } + } + } + var var121 float64 + if (input[8]) >= (0.0135719907) { + if (input[0]) >= (0.00496240612) { + if (input[0]) >= (0.00616541365) { + var121 = 0.00748342695 + } else { + var121 = -0.260428578 + } + } else { + if (input[0]) >= (0.00225563906) { + var121 = 0.233885914 + } else { + var121 = -0.139178395 + } + } + } else { + if (input[5]) >= (0.0149999997) { + if (input[8]) >= (0.0108182533) { + var121 = 0.302204281 + } else { + var121 = -0.374258548 + } + } else { + if (input[8]) >= (0.0119984262) { + var121 = -0.255583793 + } else { + var121 = -0.0115750153 + } + } + } + var var122 float64 + if (input[5]) >= (0.194999993) { + if (input[4]) >= (0.3494398) { + if (input[5]) >= (0.254999995) { + var122 = -0.318196803 + } else { + var122 = 0.0204219781 + } + } else { + if (input[4]) >= (0.184173673) { + var122 = 0.193645999 + } else { + var122 = 0.013671428 + } + } + } else { + if (input[5]) >= (0.145000011) { + if (input[4]) >= (0.282212913) { + var122 = -0.230274901 + } else { + var122 = -0.024874026 + } + } else { + if (input[4]) >= (0.0077030817) { + var122 = 0.000786224438 + } else { + var122 = 0.239714861 + } + } + } + var var123 float64 + if (input[0]) >= (0.0118796993) { + if (input[8]) >= (0.0261605028) { + if (input[0]) >= (0.0347368419) { + var123 = -0.0140690124 + } else { + var123 = 0.107350774 + } + } else { + if (input[0]) >= (0.0503759384) { + var123 = 0.17428875 + } else { + var123 = -0.0710003451 + } + } + } else { + if (input[4]) >= (0.143557429) { + if (input[8]) >= (0.0127852084) { + var123 = 0.310619414 + } else { + var123 = -0.231911078 + } + } else { + if (input[4]) >= (0.142156869) { + var123 = -0.870025098 + } else { + var123 = 0.0123206424 + } + } + } + var var124 float64 + if (input[5]) >= (0.114999995) { + if (input[4]) >= (0.489495814) { + if (input[7]) >= (0.103298433) { + var124 = 0.039091114 + } else { + var124 = -0.366690069 + } + } else { + if (input[0]) >= (0.0741353408) { + var124 = 0.0180911347 + } else { + var124 = 0.160818905 + } + } + } else { + if (input[4]) >= (0.458683491) { + if (input[9]) >= (0.0531285182) { + var124 = 0.417920023 + } else { + var124 = 0.0465288013 + } + } else { + if (input[4]) >= (0.212184876) { + var124 = -0.0291729979 + } else { + var124 = 0.00264581735 + } + } + } + var var125 float64 + if (input[4]) >= (0.740196109) { + var125 = -0.316857755 + } else { + if (input[8]) >= (0.0829399452) { + if (input[0]) >= (0.121654138) { + var125 = -0.0169537459 + } else { + var125 = 0.118023172 + } + } else { + if (input[0]) >= (0.23593986) { + var125 = 0.174380749 + } else { + var125 = -0.00535024423 + } + } + } + var var126 float64 + if (input[0]) >= (0.250075191) { + if (input[8]) >= (0.0688434318) { + var126 = -0.301149189 + } else { + if (input[1]) >= (0.010416666) { + var126 = -0.143621773 + } else { + var126 = 0.334566027 + } + } + } else { + if (input[8]) >= (0.100118019) { + if (input[4]) >= (0.0721288547) { + var126 = 0.069352068 + } else { + var126 = -0.175869375 + } + } else { + if (input[0]) >= (0.0281203017) { + var126 = -0.012853439 + } else { + var126 = 0.0105679799 + } + } + } + var var127 float64 + if (input[9]) >= (0.000187682264) { + if (input[9]) >= (0.0114197442) { + if (input[3]) >= (0.138764411) { + var127 = 0.376213312 + } else { + var127 = -0.00374712795 + } + } else { + if (input[1]) >= (0.00533536542) { + var127 = 0.0262175351 + } else { + var127 = -0.191218495 + } + } + } else { + var127 = 0.331110358 + } + var var128 float64 + if (input[4]) >= (0.684173703) { + var128 = -0.241803482 + } else { + if (input[3]) >= (0.022961922) { + if (input[4]) >= (0.065126054) { + var128 = 0.0298298113 + } else { + var128 = -0.0770601556 + } + } else { + if (input[4]) >= (0.610644281) { + var128 = 0.285727799 + } else { + var128 = -0.00581280515 + } + } + } + var var129 float64 + if (input[2]) >= (0.00451914826) { + if (input[2]) >= (0.00548912399) { + if (input[0]) >= (0.0221052617) { + var129 = -0.00104936014 + } else { + var129 = 0.02481254 + } + } else { + if (input[7]) >= (0.000166610043) { + var129 = 0.112581015 + } else { + var129 = -0.154138625 + } + } + } else { + if (input[6]) >= (0.0215702802) { + if (input[0]) >= (0.00195488706) { + var129 = -0.10938298 + } else { + var129 = -0.529833138 + } + } else { + if (input[6]) >= (0.0212391242) { + var129 = 0.506786644 + } else { + var129 = -0.00931506976 + } + } + } + var var130 float64 + if (input[6]) >= (0.00305566425) { + if (input[9]) >= (0.065818727) { + if (input[0]) >= (0.0224060155) { + var130 = -0.0764299259 + } else { + var130 = -0.00783626828 + } + } else { + if (input[0]) >= (0.0545864664) { + var130 = -0.0130933551 + } else { + var130 = 0.0203839801 + } + } + } else { + if (input[8]) >= (0.0108182533) { + if (input[8]) >= (0.0163257271) { + var130 = 0.0259690322 + } else { + var130 = -0.0873820335 + } + } else { + if (input[6]) >= (0.00185146159) { + var130 = 0.147375077 + } else { + var130 = -0.104355223 + } + } + } + var var131 float64 + if (input[2]) >= (0.333648801) { + if (input[3]) >= (0.0125538018) { + if (input[4]) >= (0.345938385) { + var131 = -0.135189548 + } else { + var131 = -0.446047574 + } + } else { + var131 = 0.069308497 + } + } else { + if (input[4]) >= (0.0161064435) { + if (input[0]) >= (0.00255639106) { + var131 = 0.00153335172 + } else { + var131 = 0.0852574036 + } + } else { + if (input[0]) >= (0.00255639106) { + var131 = -0.0171162356 + } else { + var131 = -0.326134086 + } + } + } + var var132 float64 + if (input[8]) >= (0.00976921059) { + if (input[0]) >= (0.0224060155) { + if (input[4]) >= (0.0301120449) { + var132 = -0.0115240207 + } else { + var132 = 0.123582989 + } + } else { + if (input[4]) >= (0.188375354) { + var132 = 0.170507476 + } else { + var132 = 0.00219723186 + } + } + } else { + if (input[0]) >= (0.00496240612) { + if (input[4]) >= (0.0315126069) { + var132 = -0.115836762 + } else { + var132 = 0.127661929 + } + } else { + if (input[4]) >= (0.0301120449) { + var132 = 0.144599751 + } else { + var132 = -0.141905576 + } + } + } + var var133 float64 + if (input[7]) >= (0.0111986334) { + if (input[0]) >= (0.00616541365) { + if (input[0]) >= (0.0356390998) { + var133 = 0.00356084551 + } else { + var133 = 0.0763231218 + } + } else { + if (input[0]) >= (0.00406015012) { + var133 = -0.381413251 + } else { + var133 = 0.151279971 + } + } + } else { + if (input[1]) >= (0.0424288623) { + if (input[5]) >= (0.00499999989) { + var133 = 0.0398071259 + } else { + var133 = -0.0499352403 + } + } else { + if (input[7]) >= (0.00367639307) { + var133 = -0.0317209661 + } else { + var133 = 0.0223799497 + } + } + } + var var134 float64 + if (input[5]) >= (0.795000017) { + if (input[9]) >= (0.0103369616) { + if (input[4]) >= (0.0252100844) { + var134 = -0.157192513 + } else { + var134 = 0.171405137 + } + } else { + var134 = -0.344318926 + } + } else { + if (input[4]) >= (0.00350140082) { + if (input[4]) >= (0.0119047621) { + var134 = 0.00114011369 + } else { + var134 = -0.0859108269 + } + } else { + if (input[9]) >= (0.014206104) { + var134 = 0.288605213 + } else { + var134 = 0.0407952741 + } + } + } + var var135 float64 + if (input[4]) >= (0.0259103645) { + if (input[0]) >= (0.00345864659) { + if (input[9]) >= (0.174876571) { + var135 = -0.0855526328 + } else { + var135 = 0.00598633382 + } + } else { + if (input[5]) >= (0.00499999989) { + var135 = -0.253168076 + } else { + var135 = 0.372637659 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[0]) >= (0.0751879662) { + var135 = -0.181993455 + } else { + var135 = 0.0943748727 + } + } else { + if (input[0]) >= (0.00766917318) { + var135 = -0.344649732 + } else { + var135 = -0.0217528567 + } + } + } + var var136 float64 + if (input[4]) >= (0.00350140082) { + if (input[3]) >= (0.31410405) { + var136 = -0.350905776 + } else { + if (input[7]) >= (0.438012332) { + var136 = -0.351206213 + } else { + var136 = -0.0032191975 + } + } + } else { + if (input[0]) >= (0.104511276) { + if (input[2]) >= (0.0910414234) { + var136 = 0.0526440367 + } else { + var136 = 0.30595091 + } + } else { + if (input[3]) >= (0.0119394055) { + var136 = -0.220118895 + } else { + var136 = 0.241823569 + } + } + } + var var137 float64 + if (input[8]) >= (0.148373991) { + if (input[5]) >= (0.185000002) { + if (input[0]) >= (0.12676692) { + var137 = 0.0314024948 + } else { + var137 = -0.224736229 + } + } else { + if (input[4]) >= (0.198879555) { + var137 = 0.212628871 + } else { + var137 = -0.0802598521 + } + } + } else { + if (input[5]) >= (0.0149999997) { + if (input[0]) >= (0.0395488739) { + var137 = -0.0791010857 + } else { + var137 = 0.0769828185 + } + } else { + if (input[0]) >= (0.0407518819) { + var137 = 0.0394352861 + } else { + var137 = -0.0208254158 + } + } + } + var var138 float64 + if (input[5]) >= (0.105000004) { + if (input[8]) >= (0.0228822455) { + if (input[1]) >= (0.0078760162) { + var138 = 0.0344673991 + } else { + var138 = -0.117652409 + } + } else { + if (input[1]) >= (0.124237806) { + var138 = 0.0738634095 + } else { + var138 = 0.328967512 + } + } + } else { + if (input[5]) >= (0.0149999997) { + if (input[8]) >= (0.0123918178) { + var138 = -0.0464873537 + } else { + var138 = 0.170960337 + } + } else { + if (input[8]) >= (0.0135719907) { + var138 = 0.014421423 + } else { + var138 = -0.0267122798 + } + } + } + var var139 float64 + if (input[0]) >= (0.00285714283) { + if (input[8]) >= (0.00937581994) { + if (input[8]) >= (0.0135719907) { + var139 = -0.000167242688 + } else { + var139 = -0.0456813723 + } + } else { + if (input[1]) >= (0.0368394293) { + var139 = 0.0508897342 + } else { + var139 = 0.348183692 + } + } + } else { + if (input[5]) >= (0.0149999997) { + if (input[5]) >= (0.0350000001) { + var139 = 0.168228582 + } else { + var139 = -0.695722103 + } + } else { + if (input[8]) >= (0.0110805137) { + var139 = 0.222613633 + } else { + var139 = -0.0430962667 + } + } + } + var var140 float64 + if (input[4]) >= (0.614145637) { + if (input[3]) >= (0.111825317) { + if (input[4]) >= (0.735994399) { + var140 = -0.213211253 + } else { + var140 = 0.271391213 + } + } else { + if (input[3]) >= (0.0217527039) { + var140 = -0.263317734 + } else { + var140 = 0.117851853 + } + } + } else { + if (input[4]) >= (0.0119047621) { + if (input[5]) >= (0.685000002) { + var140 = -0.214193448 + } else { + var140 = 0.00533947302 + } + } else { + if (input[1]) >= (0.102388211) { + var140 = 0.205199391 + } else { + var140 = -0.0978819653 + } + } + } + var var141 float64 + if (input[0]) >= (0.00766917318) { + if (input[8]) >= (0.0116050355) { + if (input[8]) >= (0.0119984262) { + var141 = -0.00543809682 + } else { + var141 = 0.417080313 + } + } else { + if (input[1]) >= (0.0744410604) { + var141 = 0.0707681403 + } else { + var141 = -0.290935963 + } + } + } else { + if (input[0]) >= (0.00706766918) { + if (input[6]) >= (0.00404913165) { + var141 = 0.206833869 + } else { + var141 = -0.0343035422 + } + } else { + if (input[6]) >= (0.00507270359) { + var141 = -0.0380622111 + } else { + var141 = 0.0490193404 + } + } + } + var var142 float64 + if (input[4]) >= (0.0665266141) { + if (input[8]) >= (0.0291765016) { + if (input[4]) >= (0.15196079) { + var142 = -0.0156580433 + } else { + var142 = 0.0820667669 + } + } else { + if (input[4]) >= (0.170168072) { + var142 = 0.0545320325 + } else { + var142 = -0.116160892 + } + } + } else { + if (input[4]) >= (0.0553221293) { + if (input[7]) >= (0.0271056257) { + var142 = -0.0785854906 + } else { + var142 = 0.169238329 + } + } else { + if (input[4]) >= (0.052521009) { + var142 = -0.215308845 + } else { + var142 = 0.0114129726 + } + } + } + var var143 float64 + if (input[7]) >= (0.192424655) { + if (input[2]) >= (0.226137191) { + if (input[0]) >= (0.134586468) { + var143 = -0.181136966 + } else { + var143 = 0.0966443792 + } + } else { + if (input[2]) >= (0.208639175) { + var143 = 0.417759866 + } else { + var143 = 0.0850551575 + } + } + } else { + if (input[3]) >= (0.00241563935) { + if (input[2]) >= (0.0170873962) { + var143 = -0.00749544473 + } else { + var143 = 0.00836081244 + } + } else { + if (input[1]) >= (0.0200711377) { + var143 = -0.14979291 + } else { + var143 = 0.0561823286 + } + } + } + var var144 float64 + if (input[0]) >= (0.174586475) { + if (input[4]) >= (0.0357142873) { + if (input[4]) >= (0.0567226894) { + var144 = -0.04269531 + } else { + var144 = -0.258859992 + } + } else { + if (input[5]) >= (0.0250000004) { + var144 = -0.249581754 + } else { + var144 = 0.512661815 + } + } + } else { + if (input[5]) >= (0.275000006) { + if (input[4]) >= (0.287815154) { + var144 = -0.269225121 + } else { + var144 = 0.166470662 + } + } else { + if (input[4]) >= (0.262605071) { + var144 = 0.0171948001 + } else { + var144 = -0.0089152772 + } + } + } + var var145 float64 + if (input[1]) >= (0.0165142268) { + if (input[4]) >= (0.12114846) { + if (input[3]) >= (0.0056836037) { + var145 = 0.00874270219 + } else { + var145 = 0.0979394019 + } + } else { + if (input[0]) >= (0.068721801) { + var145 = -0.105979823 + } else { + var145 = 0.00527297566 + } + } + } else { + if (input[0]) >= (0.12736842) { + if (input[1]) >= (0.00685975607) { + var145 = 0.132010326 + } else { + var145 = -0.134371415 + } + } else { + if (input[8]) >= (0.0488460511) { + var145 = -0.00926200766 + } else { + var145 = -0.136672184 + } + } + } + var var146 float64 + if (input[8]) >= (0.0108182533) { + if (input[3]) >= (0.00266322773) { + if (input[3]) >= (0.00267390418) { + var146 = -0.00135080365 + } else { + var146 = 0.202898055 + } + } else { + if (input[8]) >= (0.015670076) { + var146 = 0.00971958693 + } else { + var146 = -0.176438913 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[7]) >= (0.00759884063) { + var146 = -0.0875183716 + } else { + var146 = -0.398493946 + } + } else { + if (input[6]) >= (0.0100701451) { + var146 = -0.0929245055 + } else { + var146 = 0.0788901821 + } + } + } + var var147 float64 + if (input[0]) >= (0.158646613) { + if (input[8]) >= (0.0479281396) { + if (input[5]) >= (0.114999995) { + var147 = 0.0116372127 + } else { + var147 = -0.119947843 + } + } else { + if (input[8]) >= (0.0409782305) { + var147 = 0.29510662 + } else { + var147 = -0.0427953303 + } + } + } else { + if (input[0]) >= (0.144812018) { + if (input[8]) >= (0.0422895364) { + var147 = 0.144425467 + } else { + var147 = -0.25616923 + } + } else { + if (input[5]) >= (0.185000002) { + var147 = 0.0603768975 + } else { + var147 = -0.00253436295 + } + } + } + var var148 float64 + if (input[4]) >= (0.174369752) { + if (input[4]) >= (0.178571433) { + if (input[5]) >= (0.00499999989) { + var148 = -0.0757573321 + } else { + var148 = 0.0181486122 + } + } else { + if (input[7]) >= (0.0599030182) { + var148 = 0.0891463235 + } else { + var148 = -0.289231479 + } + } + } else { + if (input[8]) >= (0.0344217159) { + if (input[4]) >= (0.0903361365) { + var148 = 0.111774698 + } else { + var148 = -0.0176778622 + } + } else { + if (input[4]) >= (0.0931372568) { + var148 = -0.0842314661 + } else { + var148 = 0.0114371013 + } + } + } + var var149 float64 + if (input[5]) >= (0.0949999988) { + if (input[0]) >= (0.044661656) { + if (input[4]) >= (0.490896344) { + var149 = -0.212072328 + } else { + var149 = 0.0234853737 + } + } else { + if (input[0]) >= (0.0103759402) { + var149 = 0.286727399 + } else { + var149 = -0.0410271995 + } + } + } else { + if (input[5]) >= (0.075000003) { + if (input[0]) >= (0.0108270682) { + var149 = -0.0141440639 + } else { + var149 = -0.647706091 + } + } else { + if (input[7]) >= (0.0834314078) { + var149 = -0.0591427907 + } else { + var149 = 0.00273690186 + } + } + } + var var150 float64 + if (input[4]) >= (0.583333373) { + if (input[0]) >= (0.0551879704) { + if (input[3]) >= (0.0757643431) { + var150 = 0.129276305 + } else { + var150 = -0.233810782 + } + } else { + if (input[0]) >= (0.039849624) { + var150 = 0.375647277 + } else { + var150 = -0.0239509884 + } + } + } else { + if (input[4]) >= (0.528711498) { + if (input[1]) >= (0.0335365832) { + var150 = 0.323780805 + } else { + var150 = -0.189444795 + } + } else { + if (input[8]) >= (0.110739574) { + var150 = 0.0439732 + } else { + var150 = -0.00255786348 + } + } + } + var var151 float64 + if (input[0]) >= (0.00766917318) { + if (input[4]) >= (0.0203081239) { + if (input[9]) >= (0.210218579) { + var151 = -0.18726334 + } else { + var151 = -0.00214000954 + } + } else { + if (input[0]) >= (0.0127819553) { + var151 = -0.00993244816 + } else { + var151 = -0.385518759 + } + } + } else { + if (input[0]) >= (0.00706766918) { + if (input[4]) >= (0.010504202) { + var151 = 0.135531276 + } else { + var151 = -0.402445734 + } + } else { + if (input[4]) >= (0.0175070036) { + var151 = -0.0108175501 + } else { + var151 = 0.0792596713 + } + } + } + var var152 float64 + if (input[8]) >= (0.0135719907) { + if (input[2]) >= (0.0129746571) { + if (input[7]) >= (0.0112028997) { + var152 = 0.00889445283 + } else { + var152 = -0.0325963907 + } + } else { + if (input[8]) >= (0.0308811963) { + var152 = 0.062754184 + } else { + var152 = -0.00672111334 + } + } + } else { + if (input[8]) >= (0.0121295564) { + if (input[5]) >= (0.0149999997) { + var152 = 0.0844979137 + } else { + var152 = -0.205100074 + } + } else { + if (input[5]) >= (0.00499999989) { + var152 = 0.111980148 + } else { + var152 = -0.0122044692 + } + } + } + var var153 float64 + if (input[2]) >= (0.47107029) { + var153 = -0.323607534 + } else { + if (input[3]) >= (0.019142855) { + if (input[3]) >= (0.0197887719) { + var153 = 0.0163472816 + } else { + var153 = 0.207988441 + } + } else { + if (input[4]) >= (0.212184876) { + var153 = -0.0388285965 + } else { + var153 = 0.00701993704 + } + } + } + var var154 float64 + if (input[0]) >= (0.0230075195) { + if (input[4]) >= (0.0301120449) { + if (input[4]) >= (0.0553221293) { + var154 = -0.0028280546 + } else { + var154 = -0.105003953 + } + } else { + if (input[4]) >= (0.0273109246) { + var154 = 0.478357702 + } else { + var154 = 0.00307897967 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[0]) >= (0.0163909774) { + var154 = 0.378167897 + } else { + var154 = 0.037315011 + } + } else { + if (input[2]) >= (0.0472223237) { + var154 = -0.331712425 + } else { + var154 = -0.00217150222 + } + } + } + var var155 float64 + if (input[4]) >= (0.660364151) { + if (input[3]) >= (0.156331241) { + var155 = 0.0215973519 + } else { + if (input[8]) >= (0.0881851539) { + var155 = -0.25903067 + } else { + var155 = -0.0718326196 + } + } + } else { + if (input[8]) >= (0.121361136) { + if (input[5]) >= (0.145000011) { + var155 = -0.0583579727 + } else { + var155 = 0.115475424 + } + } else { + if (input[4]) >= (0.0889355764) { + var155 = -0.00992825162 + } else { + var155 = 0.00900680386 + } + } + } + var var156 float64 + if (input[0]) >= (0.121353388) { + if (input[7]) >= (0.0840557814) { + if (input[4]) >= (0.0987394974) { + var156 = 0.105499111 + } else { + var156 = -0.156945974 + } + } else { + if (input[4]) >= (0.109943978) { + var156 = -0.0594373159 + } else { + var156 = 0.0483802222 + } + } + } else { + if (input[0]) >= (0.12045113) { + if (input[1]) >= (0.0434451215) { + var156 = -0.0751423314 + } else { + var156 = 0.280899078 + } + } else { + if (input[0]) >= (0.1075188) { + var156 = -0.103808515 + } else { + var156 = 0.00496785017 + } + } + } + var var157 float64 + if (input[0]) >= (0.181804508) { + if (input[3]) >= (0.0103697358) { + if (input[3]) >= (0.0283671767) { + var157 = -0.104628295 + } else { + var157 = 0.0856563449 + } + } else { + if (input[3]) >= (0.00413909927) { + var157 = -0.225376964 + } else { + var157 = -0.0129370028 + } + } + } else { + if (input[7]) >= (0.0320443958) { + if (input[0]) >= (0.0136842104) { + var157 = 0.0289665628 + } else { + var157 = -0.215346456 + } + } else { + if (input[7]) >= (0.0313527584) { + var157 = -0.242290229 + } else { + var157 = -0.00289588119 + } + } + } + var var158 float64 + if (input[4]) >= (0.0245098043) { + if (input[5]) >= (0.675000012) { + if (input[4]) >= (0.15266107) { + var158 = -0.362932295 + } else { + var158 = -0.0518502705 + } + } else { + if (input[4]) >= (0.0385154076) { + var158 = -0.000363126688 + } else { + var158 = 0.032496538 + } + } + } else { + if (input[4]) >= (0.0231092442) { + if (input[1]) >= (0.0221036579) { + var158 = -0.22680293 + } else { + var158 = 0.250147015 + } + } else { + if (input[4]) >= (0.021708684) { + var158 = 0.103268616 + } else { + var158 = -0.0213804971 + } + } + } + var var159 float64 + if (input[0]) >= (0.00105263153) { + if (input[6]) >= (0.150043666) { + if (input[2]) >= (0.0194415655) { + var159 = -0.0609493032 + } else { + var159 = 0.33294341 + } + } else { + if (input[8]) >= (0.00976921059) { + var159 = 0.000698034011 + } else { + var159 = -0.044203192 + } + } + } else { + if (input[8]) >= (0.00937581994) { + if (input[9]) >= (0.0938411355) { + var159 = 0.28835246 + } else { + var159 = 0.0438954197 + } + } else { + if (input[0]) >= (0.000451127824) { + var159 = 0.173329294 + } else { + var159 = -0.215837315 + } + } + } + var var160 float64 + if (input[7]) >= (0.0420824476) { + if (input[4]) >= (0.297619045) { + if (input[4]) >= (0.468487382) { + var160 = -0.0924231559 + } else { + var160 = 0.0992535502 + } + } else { + if (input[8]) >= (0.0738919452) { + var160 = -0.118575223 + } else { + var160 = -0.0223002657 + } + } + } else { + if (input[7]) >= (0.0386348367) { + if (input[1]) >= (0.088160567) { + var160 = -0.0948769674 + } else { + var160 = 0.183833688 + } + } else { + if (input[4]) >= (0.370448172) { + var160 = -0.0387036875 + } else { + var160 = 0.00471006148 + } + } + } + var var161 float64 + if (input[0]) >= (0.0145864664) { + if (input[8]) >= (0.0185549445) { + if (input[4]) >= (0.0693277344) { + var161 = -0.00932896696 + } else { + var161 = 0.0596585386 + } + } else { + if (input[4]) >= (0.0455182083) { + var161 = -0.0446461365 + } else { + var161 = -0.260945737 + } + } + } else { + if (input[4]) >= (0.0903361365) { + if (input[8]) >= (0.0140965115) { + var161 = 0.216262355 + } else { + var161 = -0.182813779 + } + } else { + if (input[8]) >= (0.0327170193) { + var161 = -0.196973875 + } else { + var161 = -0.000896447455 + } + } + } + var var162 float64 + if (input[3]) >= (0.0549829304) { + if (input[6]) >= (0.0202155523) { + if (input[0]) >= (0.183759391) { + var162 = -0.197906226 + } else { + var162 = 0.176055863 + } + } else { + if (input[8]) >= (0.0786126405) { + var162 = -0.0179152321 + } else { + var162 = 0.101568311 + } + } + } else { + if (input[3]) >= (0.0498255193) { + if (input[6]) >= (0.0192371383) { + var162 = 0.0388819911 + } else { + var162 = -0.224959269 + } + } else { + if (input[3]) >= (0.039497979) { + var162 = 0.0668839961 + } else { + var162 = -0.00353730354 + } + } + } + var var163 float64 + if (input[4]) >= (0.0245098043) { + if (input[5]) >= (0.644999981) { + if (input[8]) >= (0.0683189109) { + var163 = -0.316471517 + } else { + var163 = 0.10305687 + } + } else { + if (input[1]) >= (0.158790648) { + var163 = -0.0807244778 + } else { + var163 = 0.00877166726 + } + } + } else { + if (input[4]) >= (0.0231092442) { + if (input[8]) >= (0.0105559928) { + var163 = 0.0191192254 + } else { + var163 = -0.312208533 + } + } else { + if (input[8]) >= (0.0108182533) { + var163 = -0.0375919603 + } else { + var163 = 0.0869660005 + } + } + } + var var164 float64 + if (input[3]) >= (0.0549829304) { + if (input[6]) >= (0.0023933528) { + if (input[9]) >= (0.0178442523) { + var164 = 0.208663955 + } else { + var164 = 0.0537416227 + } + } else { + if (input[1]) >= (0.11305894) { + var164 = 0.0843253285 + } else { + var164 = -0.271400005 + } + } + } else { + if (input[8]) >= (0.160437971) { + if (input[3]) >= (0.0235874988) { + var164 = -0.0770130008 + } else { + var164 = 0.224259838 + } + } else { + if (input[6]) >= (0.203450039) { + var164 = -0.25460431 + } else { + var164 = -0.00105158577 + } + } + } + var var165 float64 + if (input[4]) >= (0.240196079) { + if (input[0]) >= (0.0587969944) { + if (input[8]) >= (0.0689089969) { + var165 = 0.0134523362 + } else { + var165 = -0.0956699327 + } + } else { + if (input[7]) >= (0.0829356387) { + var165 = -0.764400363 + } else { + var165 = 0.109100163 + } + } + } else { + if (input[4]) >= (0.212184876) { + if (input[8]) >= (0.0253737215) { + var165 = -0.1552331 + } else { + var165 = 0.207323387 + } + } else { + if (input[4]) >= (0.209383756) { + var165 = 0.228579029 + } else { + var165 = -0.00227131089 + } + } + } + var var166 float64 + if (input[9]) >= (0.097551465) { + if (input[1]) >= (0.0205792673) { + if (input[0]) >= (0.0148872184) { + var166 = -0.0595923737 + } else { + var166 = 0.0310274344 + } + } else { + if (input[2]) >= (0.0202698) { + var166 = -0.0968745798 + } else { + var166 = 0.347511351 + } + } + } else { + if (input[9]) >= (0.0971472263) { + var166 = -0.39062947 + } else { + if (input[0]) >= (0.0485714301) { + var166 = 0.00704049598 + } else { + var166 = -0.018904034 + } + } + } + var var167 float64 + if (input[1]) >= (0.0261687003) { + if (input[8]) >= (0.0278651975) { + if (input[3]) >= (0.00983973313) { + var167 = 0.00581860915 + } else { + var167 = 0.109148152 + } + } else { + if (input[0]) >= (0.0272180438) { + var167 = -0.101350643 + } else { + var167 = 0.00748996111 + } + } + } else { + if (input[4]) >= (0.322829127) { + if (input[2]) >= (0.0526377745) { + var167 = 0.0994389877 + } else { + var167 = -0.203419656 + } + } else { + if (input[4]) >= (0.0273109246) { + var167 = 0.00339660491 + } else { + var167 = -0.10027951 + } + } + } + var var168 float64 + if (input[9]) >= (0.0426905006) { + if (input[0]) >= (0.0627067685) { + if (input[1]) >= (0.0154979676) { + var168 = 0.102544867 + } else { + var168 = -0.305981487 + } + } else { + if (input[8]) >= (0.0518620498) { + var168 = 0.163999468 + } else { + var168 = -0.0244274624 + } + } + } else { + if (input[0]) >= (0.0509774461) { + if (input[0]) >= (0.0524812043) { + var168 = -0.0018000456 + } else { + var168 = -0.181340441 + } + } else { + if (input[8]) >= (0.0416338854) { + var168 = 0.182958886 + } else { + var168 = 0.0238575358 + } + } + } + var var169 float64 + if (input[0]) >= (0.0485714301) { + if (input[8]) >= (0.0264227651) { + if (input[8]) >= (0.0315368474) { + var169 = 0.0102678631 + } else { + var169 = -0.171694681 + } + } else { + if (input[5]) >= (0.00999999978) { + var169 = -0.405710608 + } else { + var169 = 0.179058939 + } + } + } else { + if (input[4]) >= (0.327030838) { + if (input[8]) >= (0.0251114611) { + var169 = 0.394666046 + } else { + var169 = 0.0365819894 + } + } else { + if (input[0]) >= (0.0482706763) { + var169 = -0.323061109 + } else { + var169 = -0.0139405839 + } + } + } + var var170 float64 + if (input[9]) >= (0.0886293426) { + if (input[4]) >= (0.244397759) { + if (input[0]) >= (0.00676691718) { + var170 = -0.127423763 + } else { + var170 = 0.3102974 + } + } else { + if (input[0]) >= (0.0603007525) { + var170 = 0.412968755 + } else { + var170 = 0.0279724542 + } + } + } else { + if (input[3]) >= (0.00419095531) { + if (input[3]) >= (0.00420569861) { + var170 = 0.00146679231 + } else { + var170 = 0.544894338 + } + } else { + if (input[4]) >= (0.188375354) { + var170 = 0.0522939079 + } else { + var170 = -0.0477037281 + } + } + } + var var171 float64 + if (input[1]) >= (0.00330284564) { + if (input[3]) >= (0.00913713127) { + if (input[4]) >= (0.237394959) { + var171 = 0.0290249959 + } else { + var171 = -0.00479551405 + } + } else { + if (input[4]) >= (0.241596639) { + var171 = -0.0910276696 + } else { + var171 = -0.00118189212 + } + } + } else { + if (input[0]) >= (0.107969925) { + if (input[2]) >= (0.0933861881) { + var171 = -0.0370101742 + } else { + var171 = -0.407472908 + } + } else { + var171 = 0.265172571 + } + } + var var172 float64 + if (input[0]) >= (0.0539849624) { + if (input[7]) >= (0.000983608887) { + if (input[0]) >= (0.0584962405) { + var172 = -0.0145154251 + } else { + var172 = -0.114525028 + } + } else { + if (input[1]) >= (0.0434451215) { + var172 = -0.0513614453 + } else { + var172 = 0.134299487 + } + } + } else { + if (input[4]) >= (0.327030838) { + if (input[4]) >= (0.334033608) { + var172 = 0.132817522 + } else { + var172 = 0.372594297 + } + } else { + if (input[4]) >= (0.200980395) { + var172 = -0.0699927062 + } else { + var172 = 0.0159842949 + } + } + } + var var173 float64 + if (input[7]) >= (0.277997196) { + if (input[5]) >= (0.0250000004) { + if (input[0]) >= (0.10240601) { + var173 = -0.13254784 + } else { + var173 = -0.468685389 + } + } else { + if (input[7]) >= (0.356018037) { + var173 = 0.175009266 + } else { + var173 = -0.117722698 + } + } + } else { + if (input[7]) >= (0.182734251) { + if (input[0]) >= (0.137593985) { + var173 = -0.108324744 + } else { + var173 = 0.182718471 + } + } else { + if (input[2]) >= (0.159426838) { + var173 = -0.0744064674 + } else { + var173 = 0.00291546597 + } + } + } + var var174 float64 + if (input[1]) >= (0.0673272386) { + if (input[9]) >= (0.0993272364) { + if (input[2]) >= (0.00619503483) { + var174 = -0.0473425686 + } else { + var174 = -0.332697183 + } + } else { + if (input[9]) >= (0.00116940495) { + var174 = 0.0391502082 + } else { + var174 = -0.124707893 + } + } + } else { + if (input[0]) >= (0.084360905) { + if (input[4]) >= (0.258403361) { + var174 = -0.0497853942 + } else { + var174 = 0.00527690118 + } + } else { + if (input[4]) >= (0.262605071) { + var174 = 0.0922066718 + } else { + var174 = -0.00520593999 + } + } + } + var var175 float64 + if (input[4]) >= (0.370448172) { + if (input[2]) >= (0.079676792) { + if (input[0]) >= (0.161052644) { + var175 = 0.359470129 + } else { + var175 = 0.0493303947 + } + } else { + if (input[7]) >= (0.00402160082) { + var175 = -0.136931956 + } else { + var175 = 0.00837377924 + } + } + } else { + if (input[6]) >= (0.0315049514) { + if (input[2]) >= (0.0122657437) { + var175 = 0.00564258359 + } else { + var175 = -0.0902563259 + } + } else { + if (input[2]) >= (0.141827136) { + var175 = -0.07604862 + } else { + var175 = 0.00675144792 + } + } + } + var var176 float64 + if (input[8]) >= (0.0466168374) { + if (input[0]) >= (0.0578947365) { + if (input[6]) >= (0.0268988758) { + var176 = 0.0623778217 + } else { + var176 = -0.0115356436 + } + } else { + if (input[7]) >= (0.0982554257) { + var176 = -0.30299446 + } else { + var176 = 0.124773137 + } + } + } else { + if (input[1]) >= (0.0139735769) { + if (input[8]) >= (0.0395357981) { + var176 = -0.0544881262 + } else { + var176 = 0.00354567263 + } + } else { + if (input[0]) >= (0.0494736843) { + var176 = -0.215462968 + } else { + var176 = 0.00768874958 + } + } + } + var var177 float64 + if (input[3]) >= (0.00207781093) { + if (input[9]) >= (0.000187682264) { + if (input[6]) >= (0.00164072611) { + var177 = 0.00324161956 + } else { + var177 = -0.0305442791 + } + } else { + if (input[1]) >= (0.0594512187) { + var177 = 0.0566447936 + } else { + var177 = 0.304141849 + } + } + } else { + if (input[6]) >= (0.0390161648) { + if (input[4]) >= (0.172268912) { + var177 = -0.114801303 + } else { + var177 = 0.110861234 + } + } else { + var177 = 0.289621949 + } + } + var var178 float64 + if (input[6]) >= (0.00152030587) { + if (input[6]) >= (0.00185146159) { + if (input[9]) >= (0.0017180146) { + var178 = 0.00217583077 + } else { + var178 = -0.059153866 + } + } else { + if (input[8]) >= (0.018161552) { + var178 = -0.0116098551 + } else { + var178 = -0.128228977 + } + } + } else { + if (input[8]) >= (0.0143587729) { + if (input[9]) >= (0.147388339) { + var178 = 0.383228332 + } else { + var178 = 0.0684972256 + } + } else { + if (input[2]) >= (0.00162163202) { + var178 = -0.161133468 + } else { + var178 = 0.0630592257 + } + } + } + var var179 float64 + if (input[4]) >= (0.660364151) { + if (input[0]) >= (0.12556392) { + if (input[6]) >= (0.0153686367) { + var179 = -0.30191946 + } else { + var179 = -0.110212922 + } + } else { + var179 = -0.025946429 + } + } else { + if (input[4]) >= (0.460084021) { + if (input[5]) >= (0.0649999976) { + var179 = -0.103539117 + } else { + var179 = 0.115529485 + } + } else { + if (input[1]) >= (0.107469514) { + var179 = -0.0481113605 + } else { + var179 = -0.000602907268 + } + } + } + var var180 float64 + if (input[0]) >= (0.00827067718) { + if (input[0]) >= (0.0112781953) { + if (input[0]) >= (0.0118796993) { + var180 = -0.00278469268 + } else { + var180 = 0.158401221 + } + } else { + if (input[4]) >= (0.0343137272) { + var180 = 0.0449565686 + } else { + var180 = -0.315951109 + } + } + } else { + if (input[5]) >= (0.0850000009) { + if (input[5]) >= (0.0949999988) { + var180 = 0.0493172668 + } else { + var180 = -0.612598419 + } + } else { + if (input[5]) >= (0.0149999997) { + var180 = 0.105781384 + } else { + var180 = 0.00667789718 + } + } + } + var var181 float64 + if (input[0]) >= (0.0485714301) { + if (input[4]) >= (0.15196079) { + if (input[8]) >= (0.0929058492) { + var181 = 0.0533713624 + } else { + var181 = -0.0260045938 + } + } else { + if (input[0]) >= (0.0548872203) { + var181 = 0.00290083652 + } else { + var181 = 0.252074718 + } + } + } else { + if (input[0]) >= (0.0482706763) { + if (input[4]) >= (0.114145659) { + var181 = 0.0550516285 + } else { + var181 = -1.13329101 + } + } else { + if (input[4]) >= (0.338235319) { + var181 = 0.157803372 + } else { + var181 = -0.0106846411 + } + } + } + var var182 float64 + if (input[1]) >= (0.0038109757) { + if (input[1]) >= (0.0114329271) { + if (input[0]) >= (0.123759396) { + var182 = -0.0327697732 + } else { + var182 = 0.00219755759 + } + } else { + if (input[0]) >= (0.12676692) { + var182 = 0.137625381 + } else { + var182 = -0.0209834389 + } + } + } else { + if (input[9]) >= (0.0158808082) { + if (input[1]) >= (0.00279471534) { + var182 = 0.147861362 + } else { + var182 = -0.116522558 + } + } else { + if (input[0]) >= (0.11473684) { + var182 = -0.411130041 + } else { + var182 = 0.0284649506 + } + } + } + var var183 float64 + if (input[8]) >= (0.00976921059) { + if (input[0]) >= (0.00436090212) { + if (input[9]) >= (0.0452025533) { + var183 = -0.0134079736 + } else { + var183 = 0.0091663897 + } + } else { + if (input[2]) >= (0.00276658428) { + var183 = 0.104583926 + } else { + var183 = -0.0191450212 + } + } + } else { + if (input[0]) >= (0.00526315812) { + if (input[5]) >= (0.00499999989) { + var183 = -0.336510003 + } else { + var183 = 0.156051904 + } + } else { + if (input[3]) >= (0.0025526518) { + var183 = -0.154375583 + } else { + var183 = 0.174702004 + } + } + } + var var184 float64 + if (input[6]) >= (0.00185146159) { + if (input[8]) >= (0.113231048) { + if (input[4]) >= (0.179971993) { + var184 = 0.085824199 + } else { + var184 = -0.086115025 + } + } else { + if (input[5]) >= (0.305000007) { + var184 = 0.107777208 + } else { + var184 = -0.00131451408 + } + } + } else { + if (input[9]) >= (0.00974504091) { + if (input[8]) >= (0.0138342511) { + var184 = -0.0260708388 + } else { + var184 = -0.120765291 + } + } else { + if (input[3]) >= (0.0209865496) { + var184 = -0.0571344122 + } else { + var184 = 0.206351236 + } + } + } + var var185 float64 + if (input[9]) >= (0.253414392) { + if (input[9]) >= (0.361014068) { + if (input[0]) >= (0.00616541365) { + var185 = -0.228113666 + } else { + var185 = 0.0587360151 + } + } else { + if (input[0]) >= (0.00195488706) { + var185 = -0.142193809 + } else { + var185 = 0.0929445773 + } + } + } else { + if (input[9]) >= (0.195608228) { + if (input[0]) >= (0.0142857144) { + var185 = -0.118788898 + } else { + var185 = 0.0912216902 + } + } else { + if (input[9]) >= (0.189804524) { + var185 = -0.13010399 + } else { + var185 = 0.00447146269 + } + } + } + var var186 float64 + if (input[4]) >= (0.0511204489) { + if (input[4]) >= (0.0553221293) { + if (input[4]) >= (0.0581232496) { + var186 = -0.00519857369 + } else { + var186 = 0.212981641 + } + } else { + if (input[5]) >= (0.075000003) { + var186 = 0.0927199796 + } else { + var186 = -0.227245733 + } + } + } else { + if (input[2]) >= (0.0455388315) { + if (input[9]) >= (0.0156931244) { + var186 = -0.0203138869 + } else { + var186 = -0.196029767 + } + } else { + if (input[4]) >= (0.0483193286) { + var186 = 0.168478534 + } else { + var186 = 0.0119648697 + } + } + } + var var187 float64 + if (input[8]) >= (0.00806451589) { + if (input[8]) >= (0.00976921059) { + if (input[8]) >= (0.0108182533) { + var187 = -0.0012445288 + } else { + var187 = 0.0666366741 + } + } else { + if (input[4]) >= (0.0567226931) { + var187 = 0.42969498 + } else { + var187 = -0.0683143139 + } + } + } else { + if (input[7]) >= (0.0115326662) { + var187 = -0.287928164 + } else { + if (input[6]) >= (0.00254387828) { + var187 = 0.228047565 + } else { + var187 = -0.0654921085 + } + } + } + var var188 float64 + if (input[7]) >= (0.0124238264) { + if (input[8]) >= (0.030750066) { + if (input[9]) >= (0.0239511449) { + var188 = -0.0334276073 + } else { + var188 = 0.0252642687 + } + } else { + if (input[9]) >= (0.0656454861) { + var188 = -0.0112989638 + } else { + var188 = 0.107142963 + } + } + } else { + if (input[8]) >= (0.0337660648) { + if (input[9]) >= (0.0559726283) { + var188 = 0.141788483 + } else { + var188 = -0.00741121219 + } + } else { + if (input[5]) >= (0.0649999976) { + var188 = 0.117802702 + } else { + var188 = -0.0266430918 + } + } + } + var var189 float64 + if (input[0]) >= (0.250075191) { + if (input[8]) >= (0.0688434318) { + var189 = -0.285649151 + } else { + if (input[8]) >= (0.0645816922) { + var189 = 0.504985392 + } else { + var189 = -0.0666951612 + } + } + } else { + if (input[6]) >= (0.108122349) { + if (input[8]) >= (0.0159323364) { + var189 = -0.137425601 + } else { + var189 = 0.24144955 + } + } else { + if (input[6]) >= (0.100836918) { + var189 = 0.258245945 + } else { + var189 = 0.00307789538 + } + } + } + var var190 float64 + if (input[6]) >= (0.0212090202) { + if (input[1]) >= (0.0368394293) { + if (input[3]) >= (0.0145782307) { + var190 = -0.0257593822 + } else { + var190 = 0.0530977957 + } + } else { + if (input[8]) >= (0.0114739053) { + var190 = -0.0365210101 + } else { + var190 = -0.238515005 + } + } + } else { + if (input[6]) >= (0.0180479884) { + if (input[2]) >= (0.0384885333) { + var190 = -0.0288154837 + } else { + var190 = 0.0815552622 + } + } else { + if (input[7]) >= (2.29596772e-05) { + var190 = -0.0010277048 + } else { + var190 = 0.196033373 + } + } + } + var var191 float64 + if (input[2]) >= (0.475332975) { + var191 = -0.278271377 + } else { + if (input[4]) >= (0.174369752) { + if (input[5]) >= (0.00499999989) { + var191 = -0.0648306459 + } else { + var191 = 0.010275498 + } + } else { + if (input[8]) >= (0.0345528461) { + var191 = 0.0522509031 + } else { + var191 = -0.0130279353 + } + } + } + var var192 float64 + if (input[0]) >= (0.00105263153) { + if (input[0]) >= (0.00195488706) { + if (input[0]) >= (0.00255639106) { + var192 = -0.000365062559 + } else { + var192 = 0.0992441177 + } + } else { + if (input[5]) >= (0.0350000001) { + var192 = 0.262033641 + } else { + var192 = -0.119773671 + } + } + } else { + if (input[0]) >= (0.000150375941) { + if (input[8]) >= (0.00832677633) { + var192 = 0.0838213563 + } else { + var192 = 0.234563276 + } + } else { + var192 = -0.196246609 + } + } + var var193 float64 + if (input[9]) >= (0.135492161) { + if (input[6]) >= (0.00441039214) { + if (input[4]) >= (0.259803951) { + var193 = -0.213127568 + } else { + var193 = -0.00135368889 + } + } else { + if (input[4]) >= (0.0273109246) { + var193 = 0.00316015794 + } else { + var193 = 0.100458123 + } + } + } else { + if (input[9]) >= (0.134279445) { + if (input[4]) >= (0.0455182083) { + var193 = -0.457902461 + } else { + var193 = -0.137566179 + } + } else { + if (input[5]) >= (0.245000005) { + var193 = 0.0377120487 + } else { + var193 = -0.00583023904 + } + } + } + var var194 float64 + if (input[4]) >= (0.137955189) { + if (input[0]) >= (0.243157893) { + if (input[4]) >= (0.412464976) { + var194 = -0.0321416594 + } else { + var194 = -0.33506164 + } + } else { + if (input[4]) >= (0.14915967) { + var194 = 0.00609289063 + } else { + var194 = 0.110638291 + } + } + } else { + if (input[7]) >= (0.209942266) { + if (input[4]) >= (0.0567226894) { + var194 = -0.130173683 + } else { + var194 = -0.529955268 + } + } else { + if (input[4]) >= (0.135154068) { + var194 = -0.200807527 + } else { + var194 = -0.00354404445 + } + } + } + var var195 float64 + if (input[3]) >= (0.300652921) { + var195 = -0.303942442 + } else { + if (input[3]) >= (0.00246495381) { + if (input[3]) >= (0.00250410009) { + var195 = -0.00218215818 + } else { + var195 = -0.10245081 + } + } else { + if (input[3]) >= (0.00245783618) { + var195 = 0.389174134 + } else { + var195 = 0.0313964747 + } + } + } + var var196 float64 + if (input[3]) >= (0.0226037558) { + if (input[4]) >= (0.142156869) { + if (input[8]) >= (0.0677288249) { + var196 = 0.0589102246 + } else { + var196 = -0.0173635203 + } + } else { + if (input[5]) >= (0.38499999) { + var196 = 0.168818057 + } else { + var196 = -0.0573034808 + } + } + } else { + if (input[7]) >= (0.166712254) { + if (input[4]) >= (0.295518219) { + var196 = 0.41205591 + } else { + var196 = 0.0422935858 + } + } else { + if (input[4]) >= (0.370448172) { + var196 = -0.0675416663 + } else { + var196 = -0.00159848225 + } + } + } + var var197 float64 + if (input[0]) >= (0.0281203017) { + if (input[0]) >= (0.0299248137) { + if (input[5]) >= (0.00499999989) { + var197 = -0.0279122908 + } else { + var197 = 0.00762850745 + } + } else { + if (input[1]) >= (0.0266768299) { + var197 = -0.244289935 + } else { + var197 = 0.00571836019 + } + } + } else { + if (input[0]) >= (0.0269172937) { + if (input[0]) >= (0.0272180438) { + var197 = 0.0479135104 + } else { + var197 = 0.381954134 + } + } else { + if (input[5]) >= (0.00499999989) { + var197 = 0.0561496876 + } else { + var197 = -0.00997733418 + } + } + } + var var198 float64 + if (input[4]) >= (0.566526651) { + if (input[1]) >= (0.13694106) { + if (input[4]) >= (0.657563031) { + var198 = -0.0584273487 + } else { + var198 = 0.530563712 + } + } else { + if (input[3]) >= (0.0256747156) { + var198 = 0.00935841911 + } else { + var198 = -0.204902276 + } + } + } else { + if (input[4]) >= (0.528711498) { + if (input[7]) >= (0.0209924597) { + var198 = -0.128834456 + } else { + var198 = 0.279729158 + } + } else { + if (input[4]) >= (0.510504246) { + var198 = -0.199649736 + } else { + var198 = 0.00305816019 + } + } + } + var var199 float64 + if (input[0]) >= (0.0190977454) { + if (input[8]) >= (0.0184238125) { + if (input[0]) >= (0.0272180438) { + var199 = -0.00222766446 + } else { + var199 = 0.0547681227 + } + } else { + if (input[0]) >= (0.0272180438) { + var199 = -0.0247659013 + } else { + var199 = -0.273130089 + } + } + } else { + if (input[8]) >= (0.0336349346) { + if (input[0]) >= (0.00646616518) { + var199 = -0.00147006731 + } else { + var199 = -0.388142586 + } + } else { + if (input[7]) >= (0.0372592881) { + var199 = -0.192931071 + } else { + var199 = 0.0246852953 + } + } + } + var var200 float64 + if (input[7]) >= (0.0112039167) { + if (input[9]) >= (0.149221838) { + if (input[1]) >= (0.0266768299) { + var200 = 0.00552165601 + } else { + var200 = 0.317073166 + } + } else { + if (input[9]) >= (0.055019781) { + var200 = -0.049407687 + } else { + var200 = 0.0212643389 + } + } + } else { + if (input[7]) >= (0.0109042209) { + if (input[4]) >= (0.242997199) { + var200 = 0.10363277 + } else { + var200 = -0.25523591 + } + } else { + if (input[1]) >= (0.0210873988) { + var200 = -0.0111785065 + } else { + var200 = 0.0278273635 + } + } + } + var var201 float64 + if (input[2]) >= (0.20887281) { + if (input[0]) >= (0.0527819544) { + if (input[9]) >= (0.0127190836) { + var201 = 0.147554085 + } else { + var201 = 0.0112860007 + } + } else { + var201 = -0.196247816 + } + } else { + if (input[2]) >= (0.19894141) { + if (input[2]) >= (0.203298599) { + var201 = 0.00891063828 + } else { + var201 = -0.357353479 + } + } else { + if (input[3]) >= (0.022961922) { + var201 = 0.0154557424 + } else { + var201 = -0.00535945827 + } + } + } + var var202 float64 + if (input[4]) >= (0.0119047621) { + if (input[4]) >= (0.35084033) { + if (input[2]) >= (0.0895262957) { + var202 = 0.0712020919 + } else { + var202 = -0.0425037071 + } + } else { + if (input[3]) >= (0.0920945108) { + var202 = -0.113698728 + } else { + var202 = 0.00602909597 + } + } + } else { + if (input[8]) >= (0.0131786) { + if (input[8]) >= (0.0160634667) { + var202 = -0.00886877067 + } else { + var202 = -0.385864973 + } + } else { + if (input[4]) >= (0.00910364185) { + var202 = 0.314993978 + } else { + var202 = -0.136518776 + } + } + } + var var203 float64 + if (input[4]) >= (0.702380955) { + var203 = -0.238368914 + } else { + if (input[7]) >= (0.0419924371) { + if (input[2]) >= (0.0489872992) { + var203 = -0.0129685067 + } else { + var203 = -0.234340519 + } + } else { + if (input[7]) >= (0.0396771654) { + var203 = 0.138702795 + } else { + var203 = 0.00180098426 + } + } + } + var var204 float64 + if (input[8]) >= (0.0135719907) { + if (input[0]) >= (0.00496240612) { + if (input[0]) >= (0.00616541365) { + var204 = 0.00529295346 + } else { + var204 = -0.163227856 + } + } else { + if (input[0]) >= (0.00315789459) { + var204 = 0.230013713 + } else { + var204 = -0.12042065 + } + } + } else { + if (input[6]) >= (0.0100701451) { + if (input[0]) >= (0.00315789459) { + var204 = -0.137822837 + } else { + var204 = 0.0378690995 + } + } else { + if (input[8]) >= (0.011867296) { + var204 = -0.0936183706 + } else { + var204 = 0.0317978188 + } + } + } + var var205 float64 + if (input[8]) >= (0.0392735377) { + if (input[4]) >= (0.182773113) { + if (input[3]) >= (0.0115746316) { + var205 = -0.0111127701 + } else { + var205 = -0.100864835 + } + } else { + if (input[4]) >= (0.179971993) { + var205 = 0.409006715 + } else { + var205 = 0.008808529 + } + } + } else { + if (input[4]) >= (0.188375354) { + if (input[1]) >= (0.0266768299) { + var205 = 0.0242794733 + } else { + var205 = 0.154981926 + } + } else { + if (input[4]) >= (0.186974794) { + var205 = -0.478534937 + } else { + var205 = 0.0011758426 + } + } + } + var var206 float64 + if (input[8]) >= (0.248557568) { + if (input[4]) >= (0.198179275) { + if (input[8]) >= (0.281733543) { + var206 = 0.119960025 + } else { + var206 = 0.357732207 + } + } else { + var206 = -0.17715326 + } + } else { + if (input[4]) >= (0.642156839) { + if (input[1]) >= (0.150660574) { + var206 = 0.142246932 + } else { + var206 = -0.20432061 + } + } else { + if (input[9]) >= (0.210622817) { + var206 = -0.0381634645 + } else { + var206 = 0.00107039337 + } + } + } + var var207 float64 + if (input[6]) >= (0.220910966) { + var207 = -0.280890942 + } else { + if (input[4]) >= (0.614145637) { + if (input[8]) >= (0.235444531) { + var207 = 0.200451985 + } else { + var207 = -0.155569017 + } + } else { + if (input[4]) >= (0.528711498) { + var207 = 0.0679695681 + } else { + var207 = 0.00110054039 + } + } + } + var var208 float64 + if (input[0]) >= (0.0100751882) { + if (input[0]) >= (0.0112781953) { + if (input[0]) >= (0.0121804513) { + var208 = -0.00639099488 + } else { + var208 = 0.0972129852 + } + } else { + if (input[4]) >= (0.0273109246) { + var208 = -0.0520212054 + } else { + var208 = -0.510729373 + } + } + } else { + if (input[8]) >= (0.0133097302) { + if (input[4]) >= (0.0315126069) { + var208 = 0.16733487 + } else { + var208 = -0.0293383282 + } + } else { + if (input[4]) >= (0.0385154076) { + var208 = -0.241884977 + } else { + var208 = 0.00746219559 + } + } + } + var var209 float64 + if (input[7]) >= (0.00127212866) { + if (input[7]) >= (0.00129122788) { + if (input[0]) >= (0.0669172928) { + var209 = -0.0091521712 + } else { + var209 = 0.013065598 + } + } else { + if (input[6]) >= (0.00901646726) { + var209 = 0.363039285 + } else { + var209 = -0.0134338113 + } + } + } else { + if (input[0]) >= (0.0485714301) { + if (input[3]) >= (0.0110512394) { + var209 = 0.0403508022 + } else { + var209 = -0.0386326574 + } + } else { + if (input[3]) >= (0.00632214779) { + var209 = -0.095186688 + } else { + var209 = 0.00220255787 + } + } + } + var var210 float64 + if (input[0]) >= (0.158646613) { + if (input[1]) >= (0.066310972) { + if (input[7]) >= (0.0295870993) { + var210 = -0.0553067885 + } else { + var210 = 0.210596666 + } + } else { + if (input[1]) >= (0.0134654474) { + var210 = -0.10559237 + } else { + var210 = 0.0234191939 + } + } + } else { + if (input[0]) >= (0.157443613) { + if (input[1]) >= (0.0124491872) { + var210 = 0.0832600296 + } else { + var210 = 0.458295017 + } + } else { + if (input[3]) >= (0.00419400539) { + var210 = 0.0104370276 + } else { + var210 = -0.00830824766 + } + } + } + var var211 float64 + if (input[9]) >= (0.0924118608) { + if (input[1]) >= (0.0200711377) { + if (input[7]) >= (0.000381374441) { + var211 = 0.0206242073 + } else { + var211 = -0.065682292 + } + } else { + if (input[7]) >= (0.0158438031) { + var211 = -0.00159534137 + } else { + var211 = 0.224502742 + } + } + } else { + if (input[3]) >= (0.00410224032) { + if (input[3]) >= (0.0043973634) { + var211 = -0.00219609309 + } else { + var211 = 0.0909863412 + } + } else { + if (input[7]) >= (0.139953658) { + var211 = 0.243309408 + } else { + var211 = -0.0311313793 + } + } + } + var var212 float64 + if (input[5]) >= (0.834999979) { + if (input[7]) >= (0.0426123515) { + var212 = -0.279085457 + } else { + var212 = -0.0819299445 + } + } else { + if (input[4]) >= (0.00350140082) { + if (input[1]) >= (0.327489853) { + var212 = -0.209255055 + } else { + var212 = 0.00130006135 + } + } else { + if (input[9]) >= (0.0152744493) { + var212 = 0.285093665 + } else { + var212 = 0.0511078238 + } + } + } + var var213 float64 + if (input[3]) >= (0.00321178627) { + if (input[3]) >= (0.0032255128) { + if (input[7]) >= (0.000123738428) { + var213 = -0.00475285714 + } else { + var213 = 0.0522759929 + } + } else { + if (input[8]) >= (0.0189483352) { + var213 = -0.40901342 + } else { + var213 = -0.174668223 + } + } + } else { + if (input[5]) >= (0.0249999985) { + if (input[4]) >= (0.0280112047) { + var213 = -0.150717109 + } else { + var213 = 0.0775812268 + } + } else { + if (input[4]) >= (0.228991598) { + var213 = -0.123227403 + } else { + var213 = 0.0511451475 + } + } + } + var var214 float64 + if (input[9]) >= (0.210622817) { + if (input[6]) >= (0.00389860617) { + if (input[0]) >= (0.00345864659) { + var214 = -0.143381834 + } else { + var214 = -0.0149892597 + } + } else { + if (input[0]) >= (0.00616541365) { + var214 = -0.127015114 + } else { + var214 = 0.0689806044 + } + } + } else { + if (input[9]) >= (0.206811428) { + if (input[1]) >= (0.03125) { + var214 = 0.292450637 + } else { + var214 = -0.0420863628 + } + } else { + if (input[6]) >= (0.00197188184) { + var214 = 0.00295363832 + } else { + var214 = -0.0258751847 + } + } + } + var var215 float64 + if (input[7]) >= (0.226886511) { + if (input[4]) >= (0.0630252138) { + if (input[6]) >= (0.0102056172) { + var215 = 0.124682672 + } else { + var215 = -0.139518037 + } + } else { + var215 = -0.445228249 + } + } else { + if (input[2]) >= (0.179716259) { + if (input[2]) >= (0.187716514) { + var215 = 0.0407549664 + } else { + var215 = 0.242993847 + } + } else { + if (input[2]) >= (0.168211699) { + var215 = -0.121108927 + } else { + var215 = -0.00294817681 + } + } + } + var var216 float64 + if (input[0]) >= (0.119849622) { + if (input[0]) >= (0.12105263) { + if (input[4]) >= (0.0581232496) { + var216 = 0.0122937979 + } else { + var216 = -0.0992761329 + } + } else { + if (input[3]) >= (0.0218508225) { + var216 = 0.181386024 + } else { + var216 = -0.218245015 + } + } + } else { + if (input[0]) >= (0.11383459) { + if (input[2]) >= (0.0401446) { + var216 = -0.0394501388 + } else { + var216 = -0.287133157 + } + } else { + if (input[4]) >= (0.371848762) { + var216 = -0.090510875 + } else { + var216 = 0.000486368896 + } + } + } + var var217 float64 + if (input[3]) >= (0.0284897014) { + if (input[2]) >= (0.0238484014) { + if (input[2]) >= (0.0261411089) { + var217 = -0.0293140113 + } else { + var217 = 0.26677072 + } + } else { + if (input[8]) >= (0.0390112773) { + var217 = -0.0691014379 + } else { + var217 = -0.599956632 + } + } + } else { + if (input[3]) >= (0.0250071939) { + if (input[6]) >= (0.0263118297) { + var217 = 0.185334474 + } else { + var217 = 0.0282347724 + } + } else { + if (input[4]) >= (0.566526651) { + var217 = -0.139888003 + } else { + var217 = -0.000951568247 + } + } + } + var var218 float64 + if (input[2]) >= (0.475332975) { + var218 = -0.235361472 + } else { + if (input[5]) >= (0.245000005) { + if (input[2]) >= (0.0211659018) { + var218 = 0.0181279797 + } else { + var218 = 0.207036719 + } + } else { + if (input[5]) >= (0.215000004) { + var218 = -0.148954988 + } else { + var218 = 0.00515237777 + } + } + } + var var219 float64 + if (input[1]) >= (0.0114329271) { + if (input[4]) >= (0.262605071) { + if (input[2]) >= (0.0155662652) { + var219 = -0.0088064475 + } else { + var219 = 0.128366411 + } + } else { + if (input[4]) >= (0.259803951) { + var219 = -0.268847346 + } else { + var219 = -0.00556295551 + } + } + } else { + if (input[4]) >= (0.226190478) { + if (input[4]) >= (0.539915979) { + var219 = 0.298265725 + } else { + var219 = -0.127958491 + } + } else { + if (input[3]) >= (0.0065905801) { + var219 = 0.236847311 + } else { + var219 = 0.0295897629 + } + } + } + var var220 float64 + if (input[5]) >= (0.0450000018) { + if (input[0]) >= (0.044661656) { + if (input[2]) >= (0.0559533089) { + var220 = 0.0415058546 + } else { + var220 = -0.0634036362 + } + } else { + if (input[0]) >= (0.0103759402) { + var220 = 0.194350839 + } else { + var220 = -0.0459684283 + } + } + } else { + if (input[0]) >= (0.0452631563) { + if (input[4]) >= (0.0441176482) { + var220 = -0.00184265338 + } else { + var220 = 0.350384533 + } + } else { + if (input[0]) >= (0.00766917318) { + var220 = -0.0427453034 + } else { + var220 = 0.0140413437 + } + } + } + var var221 float64 + if (input[8]) >= (0.209021762) { + if (input[4]) >= (0.198179275) { + if (input[0]) >= (0.128571421) { + var221 = 0.132159114 + } else { + var221 = -0.262558788 + } + } else { + if (input[4]) >= (0.0532212891) { + var221 = -0.382075191 + } else { + var221 = 0.174856991 + } + } + } else { + if (input[4]) >= (0.636554599) { + if (input[8]) >= (0.0859559402) { + var221 = -0.210411549 + } else { + var221 = 0.0433335565 + } + } else { + if (input[4]) >= (0.458683491) { + var221 = 0.0509749539 + } else { + var221 = 0.00149767473 + } + } + } + var var222 float64 + if (input[4]) >= (0.233193278) { + if (input[6]) >= (0.079507485) { + if (input[2]) >= (0.0164329372) { + var222 = 0.117771707 + } else { + var222 = 0.375779837 + } + } else { + if (input[9]) >= (0.0398030803) { + var222 = 0.0541968569 + } else { + var222 = -0.00382577907 + } + } + } else { + if (input[6]) >= (0.102884069) { + if (input[3]) >= (0.00306994398) { + var222 = -0.217194602 + } else { + var222 = 0.116553523 + } + } else { + if (input[4]) >= (0.212184876) { + var222 = -0.0680336431 + } else { + var222 = 0.00140078354 + } + } + } + var var223 float64 + if (input[6]) >= (0.0149471648) { + if (input[6]) >= (0.0151579008) { + if (input[2]) >= (0.00736821536) { + var223 = 0.0221154727 + } else { + var223 = -0.0394442603 + } + } else { + if (input[9]) >= (0.012921202) { + var223 = 0.262764931 + } else { + var223 = 0.036550615 + } + } + } else { + if (input[1]) >= (0.0373475626) { + if (input[2]) >= (0.0188840032) { + var223 = 0.00787440315 + } else { + var223 = -0.0390984192 + } + } else { + if (input[5]) >= (0.0149999997) { + var223 = -0.03186813 + } else { + var223 = 0.0228690002 + } + } + } + var var224 float64 + if (input[5]) >= (0.105000004) { + if (input[0]) >= (0.0539849624) { + if (input[3]) >= (0.00310603995) { + var224 = 0.00990169588 + } else { + var224 = -0.236220509 + } + } else { + if (input[0]) >= (0.00616541365) { + var224 = 0.178399682 + } else { + var224 = -0.150705785 + } + } + } else { + if (input[0]) >= (0.158646613) { + if (input[6]) >= (0.0135623328) { + var224 = 0.0477009304 + } else { + var224 = -0.112649091 + } + } else { + if (input[0]) >= (0.126466155) { + var224 = 0.0571194924 + } else { + var224 = -0.00439347979 + } + } + } + var var225 float64 + if (input[3]) >= (0.255182326) { + if (input[3]) >= (0.31410405) { + var225 = 0.00465196744 + } else { + var225 = 0.322344273 + } + } else { + if (input[3]) >= (0.183460474) { + if (input[4]) >= (0.364145666) { + var225 = 0.101658694 + } else { + var225 = -0.426100135 + } + } else { + if (input[1]) >= (0.0327743888) { + var225 = 0.00772967236 + } else { + var225 = -0.00698190974 + } + } + } + var var226 float64 + if (input[3]) >= (0.0280733258) { + if (input[7]) >= (0.0172270723) { + if (input[4]) >= (0.0931372568) { + var226 = -0.0294360835 + } else { + var226 = -0.18584457 + } + } else { + if (input[4]) >= (0.285014033) { + var226 = -0.0731543973 + } else { + var226 = 0.0509466566 + } + } + } else { + if (input[3]) >= (0.0277436301) { + if (input[0]) >= (0.125263155) { + var226 = 0.38695547 + } else { + var226 = 0.118447565 + } + } else { + if (input[0]) >= (0.273834586) { + var226 = 0.15725559 + } else { + var226 = -0.00155599241 + } + } + } + var var227 float64 + if (input[7]) >= (8.91973323e-05) { + if (input[7]) >= (0.000181036041) { + if (input[7]) >= (0.000219640817) { + var227 = -0.00240835128 + } else { + var227 = -0.080885537 + } + } else { + if (input[8]) >= (0.0112116449) { + var227 = 0.0702946857 + } else { + var227 = -0.0841986313 + } + } + } else { + if (input[7]) >= (8.14763771e-05) { + if (input[8]) >= (0.0358641483) { + var227 = -0.467444897 + } else { + var227 = -0.126377478 + } + } else { + if (input[4]) >= (0.0231092442) { + var227 = -0.0667589456 + } else { + var227 = 0.0666752383 + } + } + } + var var228 float64 + if (input[5]) >= (0.0549999997) { + if (input[4]) >= (0.430672288) { + if (input[0]) >= (0.166466177) { + var228 = 0.257760853 + } else { + var228 = -0.160095051 + } + } else { + if (input[8]) >= (0.0118017308) { + var228 = 0.0358390957 + } else { + var228 = -0.348446846 + } + } + } else { + if (input[4]) >= (0.462885141) { + if (input[2]) >= (0.0430034772) { + var228 = -0.0134460898 + } else { + var228 = 0.170203656 + } + } else { + if (input[0]) >= (0.121954888) { + var228 = -0.054898221 + } else { + var228 = 0.00216833176 + } + } + } + var var229 float64 + if (input[1]) >= (0.0114329271) { + if (input[8]) >= (0.110608444) { + if (input[3]) >= (0.0238755047) { + var229 = -0.0236482695 + } else { + var229 = 0.176673606 + } + } else { + if (input[4]) >= (0.591736674) { + var229 = -0.179439917 + } else { + var229 = -0.00280085695 + } + } + } else { + if (input[4]) >= (0.0973389372) { + if (input[4]) >= (0.226190478) { + var229 = -0.0386571698 + } else { + var229 = 0.140804917 + } + } else { + if (input[8]) >= (0.0693023875) { + var229 = -0.0896000266 + } else { + var229 = 0.0452003069 + } + } + } + var var230 float64 + if (input[1]) >= (0.39354676) { + var230 = 0.299798697 + } else { + if (input[1]) >= (0.324441046) { + var230 = -0.280205816 + } else { + if (input[9]) >= (0.0911414027) { + var230 = 0.01569351 + } else { + var230 = -0.00112286315 + } + } + } + var var231 float64 + if (input[5]) >= (0.894999981) { + var231 = -0.214956224 + } else { + if (input[8]) >= (0.0108182533) { + if (input[4]) >= (0.0273109246) { + var231 = 0.00129516528 + } else { + var231 = -0.0427048877 + } + } else { + if (input[4]) >= (0.0273109246) { + var231 = -0.126573563 + } else { + var231 = 0.0750750154 + } + } + } + var var232 float64 + if (input[1]) >= (0.0673272386) { + if (input[9]) >= (0.110458232) { + if (input[3]) >= (0.0223091394) { + var232 = 0.214120269 + } else { + var232 = -0.119201139 + } + } else { + if (input[3]) >= (0.00941522419) { + var232 = 0.0174476858 + } else { + var232 = 0.185358614 + } + } + } else { + if (input[0]) >= (0.123759396) { + if (input[1]) >= (0.014989838) { + var232 = -0.0593243018 + } else { + var232 = 0.0368650518 + } + } else { + if (input[1]) >= (0.00584349595) { + var232 = -0.00041603623 + } else { + var232 = 0.13495703 + } + } + } + var var233 float64 + if (input[0]) >= (0.000150375941) { + if (input[6]) >= (0.00320618972) { + if (input[7]) >= (0.00160778698) { + var233 = 0.0053213872 + } else { + var233 = -0.0225954615 + } + } else { + if (input[7]) >= (0.000402099104) { + var233 = 0.00221417588 + } else { + var233 = 0.0724927709 + } + } + } else { + var233 = -0.238085702 + } + var var234 float64 + if (input[0]) >= (0.0221052617) { + if (input[8]) >= (0.0261605028) { + if (input[0]) >= (0.0356390998) { + var234 = -0.0069078966 + } else { + var234 = 0.0890662074 + } + } else { + if (input[0]) >= (0.0503759384) { + var234 = 0.0722678378 + } else { + var234 = -0.128722638 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[0]) >= (0.0163909774) { + var234 = 0.342902809 + } else { + var234 = 0.0505513623 + } + } else { + if (input[4]) >= (0.132352948) { + var234 = 0.0936841443 + } else { + var234 = -0.0194273517 + } + } + } + var var235 float64 + if (input[1]) >= (0.0246443078) { + if (input[1]) >= (0.0292174798) { + if (input[1]) >= (0.0317581296) { + var235 = 0.00536218937 + } else { + var235 = -0.0469127372 + } + } else { + if (input[3]) >= (0.00280964561) { + var235 = 0.0609514154 + } else { + var235 = -0.0946736038 + } + } + } else { + if (input[3]) >= (0.0207714997) { + if (input[3]) >= (0.0238727108) { + var235 = -0.0906902105 + } else { + var235 = 0.244733348 + } + } else { + if (input[4]) >= (0.0273109246) { + var235 = -0.0134286517 + } else { + var235 = -0.0999878421 + } + } + } + var var236 float64 + if (input[7]) >= (0.0324190632) { + if (input[9]) >= (0.0257990938) { + if (input[4]) >= (0.12394958) { + var236 = -0.0574490912 + } else { + var236 = 0.0399600975 + } + } else { + if (input[1]) >= (0.00889227632) { + var236 = 0.0602571853 + } else { + var236 = -0.0751295015 + } + } + } else { + if (input[7]) >= (0.0296722334) { + if (input[4]) >= (0.198179275) { + var236 = 0.0157234874 + } else { + var236 = -0.147390947 + } + } else { + if (input[4]) >= (0.465686262) { + var236 = 0.0691184178 + } else { + var236 = -0.00602223305 + } + } + } + var var237 float64 + if (input[4]) >= (0.0889355764) { + if (input[4]) >= (0.0903361365) { + if (input[0]) >= (0.0142857144) { + var237 = -0.00915796962 + } else { + var237 = 0.100283712 + } + } else { + if (input[0]) >= (0.0803007483) { + var237 = -0.14591302 + } else { + var237 = -0.564186394 + } + } + } else { + if (input[8]) >= (0.0192105956) { + if (input[0]) >= (0.0705263168) { + var237 = -0.0332467742 + } else { + var237 = 0.0717729628 + } + } else { + if (input[0]) >= (0.00857142825) { + var237 = -0.0916135907 + } else { + var237 = 0.016762672 + } + } + } + var var238 float64 + if (input[3]) >= (0.00183251023) { + if (input[9]) >= (0.000187682264) { + if (input[9]) >= (0.000274304854) { + var238 = 0.00281594414 + } else { + var238 = -0.209217817 + } + } else { + var238 = 0.209967867 + } + } else { + if (input[6]) >= (0.0564771071) { + var238 = 0.0608562008 + } else { + var238 = 0.242457107 + } + } + var var239 float64 + if (input[6]) >= (0.280383527) { + var239 = 0.271743715 + } else { + if (input[3]) >= (0.0047791684) { + if (input[8]) >= (0.0160634667) { + var239 = -0.00190170179 + } else { + var239 = 0.0649167225 + } + } else { + if (input[4]) >= (0.191176474) { + var239 = 0.0521304496 + } else { + var239 = -0.0204869341 + } + } + } + var var240 float64 + if (input[8]) >= (0.00150799891) { + if (input[1]) >= (0.09375) { + if (input[0]) >= (0.0157894753) { + var240 = 0.00385458139 + } else { + var240 = -0.0897715464 + } + } else { + if (input[1]) >= (0.0927337408) { + var240 = 0.171283886 + } else { + var240 = -0.0026086946 + } + } + } else { + var240 = 0.203963682 + } + var var241 float64 + if (input[4]) >= (0.308823526) { + if (input[5]) >= (0.375) { + if (input[7]) >= (0.108913392) { + var241 = -0.0524964668 + } else { + var241 = -0.489675999 + } + } else { + if (input[3]) >= (0.00740172435) { + var241 = -0.000351506518 + } else { + var241 = -0.12265376 + } + } + } else { + if (input[5]) >= (0.164999992) { + if (input[4]) >= (0.216386557) { + var241 = 0.230440095 + } else { + var241 = 0.00628867233 + } + } else { + if (input[5]) >= (0.145000011) { + var241 = -0.174367964 + } else { + var241 = 0.00406001927 + } + } + } + var var242 float64 + if (input[4]) >= (0.0665266141) { + if (input[0]) >= (0.00225563906) { + if (input[0]) >= (0.0127819553) { + var242 = -0.00953990594 + } else { + var242 = 0.105081923 + } + } else { + if (input[5]) >= (0.0149999997) { + var242 = -0.773412585 + } else { + var242 = 0.234310865 + } + } + } else { + if (input[0]) >= (0.0672180429) { + if (input[0]) >= (0.155639097) { + var242 = 0.0983541608 + } else { + var242 = -0.152873814 + } + } else { + if (input[0]) >= (0.0506766923) { + var242 = 0.32709977 + } else { + var242 = 0.0131211402 + } + } + } + var var243 float64 + if (input[9]) >= (0.0368867815) { + if (input[4]) >= (0.472689092) { + if (input[4]) >= (0.586134434) { + var243 = -0.187396243 + } else { + var243 = 0.353635848 + } + } else { + if (input[0]) >= (0.123458646) { + var243 = -0.335874498 + } else { + var243 = -0.0119012417 + } + } + } else { + if (input[4]) >= (0.413865566) { + if (input[0]) >= (0.0675188005) { + var243 = -0.064878121 + } else { + var243 = 0.21952033 + } + } else { + if (input[0]) >= (0.154736847) { + var243 = -0.0377906561 + } else { + var243 = 0.0190374255 + } + } + } + var var244 float64 + if (input[4]) >= (0.0665266141) { + if (input[4]) >= (0.0819327757) { + if (input[4]) >= (0.0833333358) { + var244 = -0.00426406786 + } else { + var244 = 0.374140441 + } + } else { + if (input[5]) >= (0.0450000018) { + var244 = 0.18265833 + } else { + var244 = -0.171396866 + } + } + } else { + if (input[4]) >= (0.0609243698) { + if (input[8]) >= (0.0173747707) { + var244 = 0.0820538625 + } else { + var244 = 0.390400559 + } + } else { + if (input[4]) >= (0.0595238097) { + var244 = -0.234628782 + } else { + var244 = 0.00615867134 + } + } + } + var var245 float64 + if (input[8]) >= (0.0742853433) { + if (input[0]) >= (0.123759396) { + if (input[8]) >= (0.110608444) { + var245 = 0.0342023373 + } else { + var245 = -0.06158337 + } + } else { + if (input[4]) >= (0.332633078) { + var245 = 0.173557237 + } else { + var245 = 0.00331587228 + } + } + } else { + if (input[0]) >= (0.127669185) { + if (input[0]) >= (0.128571421) { + var245 = 0.0363332368 + } else { + var245 = 0.682807446 + } + } else { + if (input[0]) >= (0.12075188) { + var245 = -0.152882412 + } else { + var245 = -0.00133195613 + } + } + } + var var246 float64 + if (input[8]) >= (0.0323236287) { + if (input[4]) >= (0.202380955) { + if (input[4]) >= (0.235994399) { + var246 = 0.00307385391 + } else { + var246 = -0.12530522 + } + } else { + if (input[0]) >= (0.0542857125) { + var246 = 0.0086228624 + } else { + var246 = 0.0853046998 + } + } + } else { + if (input[4]) >= (0.203781515) { + if (input[8]) >= (0.0148832938) { + var246 = 0.10189072 + } else { + var246 = -0.152004674 + } + } else { + if (input[4]) >= (0.0931372568) { + var246 = -0.0853395239 + } else { + var246 = 0.00877923425 + } + } + } + var var247 float64 + if (input[3]) >= (0.20521751) { + if (input[0]) >= (0.132180452) { + var247 = -0.0697622597 + } else { + if (input[0]) >= (0.113233089) { + var247 = 0.346638203 + } else { + var247 = 0.00882616919 + } + } + } else { + if (input[3]) >= (0.189342365) { + var247 = -0.374962389 + } else { + if (input[7]) >= (5.01861941e-05) { + var247 = 0.00280989544 + } else { + var247 = -0.0576611944 + } + } + } + var var248 float64 + if (input[0]) >= (0.261202991) { + if (input[8]) >= (0.0543535277) { + if (input[8]) >= (0.0688434318) { + var248 = -0.279919565 + } else { + var248 = 0.221490324 + } + } else { + if (input[8]) >= (0.0447154455) { + var248 = -0.370932758 + } else { + var248 = -0.111537665 + } + } + } else { + if (input[0]) >= (0.219699249) { + if (input[8]) >= (0.0570417009) { + var248 = -0.0797234699 + } else { + var248 = 0.242276222 + } + } else { + if (input[0]) >= (0.19894737) { + var248 = -0.0726150796 + } else { + var248 = 0.000999845332 + } + } + } + var var249 float64 + if (input[0]) >= (0.0476691723) { + if (input[0]) >= (0.0482706763) { + if (input[8]) >= (0.0163257271) { + var249 = 0.00929463562 + } else { + var249 = -0.200569123 + } + } else { + if (input[6]) >= (0.011485083) { + var249 = 0.544389248 + } else { + var249 = 0.0321287476 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[8]) >= (0.0104248626) { + var249 = 0.0361058339 + } else { + var249 = -0.340008497 + } + } else { + if (input[6]) >= (0.0384291187) { + var249 = -0.104009911 + } else { + var249 = -0.00895885378 + } + } + } + var var250 float64 + if (input[5]) >= (0.0149999997) { + if (input[0]) >= (0.00977443624) { + if (input[5]) >= (0.0249999985) { + var250 = -0.0154771637 + } else { + var250 = -0.221778646 + } + } else { + if (input[5]) >= (0.0249999985) { + var250 = 0.0156910699 + } else { + var250 = 0.171167031 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[0]) >= (0.0163909774) { + var250 = 0.756802976 + } else { + var250 = -0.0190736298 + } + } else { + if (input[4]) >= (0.0245098043) { + var250 = 0.0079392409 + } else { + var250 = -0.0380130485 + } + } + } + var var251 float64 + if (input[1]) >= (0.0205792673) { + if (input[0]) >= (0.220300764) { + if (input[3]) >= (0.0243167933) { + var251 = 0.0151184248 + } else { + var251 = 0.342957228 + } + } else { + if (input[0]) >= (0.128270686) { + var251 = -0.0376565494 + } else { + var251 = 0.00407224661 + } + } + } else { + if (input[3]) >= (0.00772480946) { + if (input[8]) >= (0.137359038) { + var251 = 0.0993890911 + } else { + var251 = -0.138713375 + } + } else { + if (input[8]) >= (0.0488460511) { + var251 = 0.0474494137 + } else { + var251 = -0.043052379 + } + } + } + var var252 float64 + if (input[4]) >= (0.116946779) { + if (input[8]) >= (0.0194728561) { + if (input[3]) >= (0.00566682639) { + var252 = -0.00342453364 + } else { + var252 = 0.0466203913 + } + } else { + if (input[4]) >= (0.379551828) { + var252 = -0.206396177 + } else { + var252 = 0.105046339 + } + } + } else { + if (input[4]) >= (0.109943978) { + if (input[2]) >= (0.0394292846) { + var252 = 0.0908965692 + } else { + var252 = -0.178953931 + } + } else { + if (input[8]) >= (0.105625495) { + var252 = -0.134739757 + } else { + var252 = -0.00177191012 + } + } + } + var var253 float64 + if (input[3]) >= (0.0235247128) { + if (input[6]) >= (0.00793268532) { + if (input[6]) >= (0.0103410911) { + var253 = 0.000166699872 + } else { + var253 = -0.0967069492 + } + } else { + if (input[3]) >= (0.0256838687) { + var253 = 0.0339413621 + } else { + var253 = 0.147459179 + } + } + } else { + if (input[3]) >= (0.0231418908) { + if (input[0]) >= (0.123458646) { + var253 = -0.198278829 + } else { + var253 = -0.042867329 + } + } else { + if (input[5]) >= (0.284999996) { + var253 = 0.106369637 + } else { + var253 = -0.0045132814 + } + } + } + var var254 float64 + if (input[8]) >= (0.0829399452) { + if (input[9]) >= (0.00472093094) { + if (input[8]) >= (0.0842512473) { + var254 = 0.00163792761 + } else { + var254 = 0.152822107 + } + } else { + if (input[3]) >= (0.00986617059) { + var254 = 0.111612104 + } else { + var254 = -0.148812205 + } + } + } else { + if (input[8]) >= (0.0793994218) { + if (input[9]) >= (0.0210348517) { + var254 = -0.0073503023 + } else { + var254 = -0.168260425 + } + } else { + if (input[5]) >= (0.114999995) { + var254 = 0.0540928766 + } else { + var254 = -0.00581327034 + } + } + } + var var255 float64 + if (input[8]) >= (0.00150799891) { + if (input[8]) >= (0.00295043271) { + if (input[9]) >= (0.00275748549) { + var255 = -0.00172710884 + } else { + var255 = -0.0363852456 + } + } else { + var255 = -0.288574725 + } + } else { + var255 = 0.284804523 + } + var var256 float64 + if (input[2]) >= (0.22617662) { + if (input[4]) >= (0.12394958) { + if (input[3]) >= (0.0233826172) { + var256 = -0.0718105286 + } else { + var256 = 0.159010708 + } + } else { + if (input[1]) >= (0.0655487776) { + var256 = -0.0408397764 + } else { + var256 = -0.445561618 + } + } + } else { + if (input[1]) >= (0.0271849595) { + if (input[1]) >= (0.0292174798) { + var256 = 0.00261979084 + } else { + var256 = 0.0767731965 + } + } else { + if (input[8]) >= (0.0839889869) { + var256 = 0.0384193771 + } else { + var256 = -0.021203164 + } + } + } + var var257 float64 + if (input[7]) >= (0.0601832047) { + if (input[7]) >= (0.0704758465) { + if (input[0]) >= (0.0765413493) { + var257 = 0.0361436456 + } else { + var257 = -0.0663998052 + } + } else { + if (input[0]) >= (0.143157899) { + var257 = -0.0769900307 + } else { + var257 = 0.150409564 + } + } + } else { + if (input[7]) >= (0.0419327021) { + if (input[1]) >= (0.0109247966) { + var257 = -0.0292297434 + } else { + var257 = -0.25629285 + } + } else { + if (input[4]) >= (0.34803921) { + var257 = -0.031437695 + } else { + var257 = 0.00384040433 + } + } + } + var var258 float64 + if (input[7]) >= (0.0111886775) { + if (input[8]) >= (0.030750066) { + if (input[3]) >= (0.00271203392) { + var258 = 0.00190350832 + } else { + var258 = -0.237898961 + } + } else { + if (input[4]) >= (0.15336135) { + var258 = 0.145659551 + } else { + var258 = 0.0199363157 + } + } + } else { + if (input[7]) >= (0.0109042209) { + if (input[8]) >= (0.0329137146) { + var258 = -0.286786586 + } else { + var258 = -0.0684095398 + } + } else { + if (input[9]) >= (0.0587445498) { + var258 = 0.0118660675 + } else { + var258 = -0.0139375618 + } + } + } + var var259 float64 + if (input[8]) >= (0.0416338854) { + if (input[0]) >= (0.0524812043) { + if (input[4]) >= (0.109943978) { + var259 = -0.00463826535 + } else { + var259 = 0.0458820313 + } + } else { + if (input[2]) >= (0.122194976) { + var259 = -0.172373846 + } else { + var259 = 0.117303081 + } + } + } else { + if (input[0]) >= (0.0618045107) { + if (input[4]) >= (0.115546219) { + var259 = 0.117271833 + } else { + var259 = -0.0834857672 + } + } else { + if (input[0]) >= (0.0548872203) { + var259 = -0.14605853 + } else { + var259 = -0.00718476577 + } + } + } + var var260 float64 + if (input[7]) >= (0.0704758465) { + if (input[8]) >= (0.0240624174) { + if (input[0]) >= (0.0536842123) { + var260 = -0.0190244913 + } else { + var260 = -0.223167762 + } + } else { + if (input[7]) >= (0.0742373765) { + var260 = 0.363763273 + } else { + var260 = -0.308575809 + } + } + } else { + if (input[7]) >= (0.0658495724) { + if (input[5]) >= (0.0649999976) { + var260 = -0.0374680981 + } else { + var260 = 0.184995472 + } + } else { + if (input[6]) >= (0.281166255) { + var260 = -0.297506034 + } else { + var260 = 0.00131972204 + } + } + } + var var261 float64 + if (input[3]) >= (0.00314111914) { + if (input[9]) >= (0.157855228) { + if (input[4]) >= (0.0203081239) { + var261 = -0.093103081 + } else { + var261 = 0.0475355536 + } + } else { + if (input[3]) >= (0.0031828077) { + var261 = 0.00279899244 + } else { + var261 = -0.139239758 + } + } + } else { + if (input[4]) >= (0.132352948) { + if (input[0]) >= (0.0732330829) { + var261 = 0.102060974 + } else { + var261 = -0.133000165 + } + } else { + if (input[5]) >= (0.0350000001) { + var261 = -0.0980298296 + } else { + var261 = 0.0559302792 + } + } + } + var var262 float64 + if (input[0]) >= (0.00526315812) { + if (input[4]) >= (0.0189075638) { + if (input[4]) >= (0.0259103645) { + var262 = 1.07284122e-05 + } else { + var262 = 0.0983347297 + } + } else { + if (input[0]) >= (0.0193984956) { + var262 = 0.0953608304 + } else { + var262 = -0.130515456 + } + } + } else { + if (input[4]) >= (0.0175070036) { + if (input[4]) >= (0.0259103645) { + var262 = 0.0353986621 + } else { + var262 = -0.111879386 + } + } else { + if (input[4]) >= (0.0147058824) { + var262 = 0.239195898 + } else { + var262 = 0.0145871853 + } + } + } + var var263 float64 + if (input[5]) >= (0.675000012) { + if (input[4]) >= (0.15266107) { + var263 = -0.401232302 + } else { + if (input[8]) >= (0.0960529745) { + var263 = -0.165644199 + } else { + var263 = 0.166692704 + } + } + } else { + if (input[8]) >= (0.0922501981) { + if (input[0]) >= (0.12556392) { + var263 = -0.0243069809 + } else { + var263 = 0.0973171815 + } + } else { + if (input[9]) >= (0.00451881159) { + var263 = -0.000383731531 + } else { + var263 = -0.0636479408 + } + } + } + var var264 float64 + if (input[1]) >= (0.108485773) { + if (input[0]) >= (0.135939851) { + if (input[7]) >= (0.0158726554) { + var264 = -0.0804398879 + } else { + var264 = 0.266873747 + } + } else { + if (input[8]) >= (0.0109493835) { + var264 = -0.0697308332 + } else { + var264 = 0.0556845069 + } + } + } else { + if (input[1]) >= (0.0322662592) { + if (input[8]) >= (0.0295698922) { + var264 = 0.0264760796 + } else { + var264 = -0.00973944552 + } + } else { + if (input[2]) >= (0.00666450709) { + var264 = -0.0177061893 + } else { + var264 = 0.0308959596 + } + } + } + var var265 float64 + if (input[0]) >= (0.0353383459) { + if (input[0]) >= (0.0407518819) { + if (input[2]) >= (0.0129556386) { + var265 = -0.014039523 + } else { + var265 = 0.0433842614 + } + } else { + if (input[4]) >= (0.230392158) { + var265 = 0.131405309 + } else { + var265 = -0.114126369 + } + } + } else { + if (input[4]) >= (0.0343137272) { + if (input[8]) >= (0.0138342511) { + var265 = 0.0355721712 + } else { + var265 = -0.0940047875 + } + } else { + if (input[0]) >= (0.00766917318) { + var265 = -0.120418921 + } else { + var265 = 0.0113616241 + } + } + } + var var266 float64 + if (input[3]) >= (0.0400170535) { + if (input[7]) >= (0.000137961237) { + if (input[7]) >= (0.00442857668) { + var266 = 0.00733893597 + } else { + var266 = 0.118046284 + } + } else { + if (input[6]) >= (0.0184694584) { + var266 = 0.0750108138 + } else { + var266 = -0.217994139 + } + } + } else { + if (input[0]) >= (0.0663157851) { + if (input[7]) >= (0.000239146379) { + var266 = -0.0222562999 + } else { + var266 = 0.104651369 + } + } else { + if (input[5]) >= (0.164999992) { + var266 = 0.213286817 + } else { + var266 = 0.00143811968 + } + } + } + var var267 float64 + if (input[9]) >= (0.716412067) { + if (input[9]) >= (0.776499271) { + var267 = -0.0197270028 + } else { + var267 = 0.367026061 + } + } else { + if (input[6]) >= (0.000556943705) { + if (input[4]) >= (0.430672288) { + var267 = -0.0288247764 + } else { + var267 = 0.00134350278 + } + } else { + var267 = -0.241354153 + } + } + var var268 float64 + if (input[3]) >= (0.111227959) { + if (input[4]) >= (0.459383756) { + if (input[4]) >= (0.702380955) { + var268 = -0.0652024522 + } else { + var268 = 0.257718742 + } + } else { + if (input[8]) >= (0.172239706) { + var268 = -0.144785672 + } else { + var268 = 0.0905320123 + } + } + } else { + if (input[4]) >= (0.642156839) { + if (input[8]) >= (0.102019407) { + var268 = -0.264144093 + } else { + var268 = -0.0758956075 + } + } else { + if (input[8]) >= (0.0458300561) { + var268 = 0.0086911479 + } else { + var268 = -0.00503181992 + } + } + } + var var269 float64 + if (input[3]) >= (0.0261724368) { + if (input[3]) >= (0.0262329355) { + if (input[1]) >= (0.0998475626) { + var269 = 0.0211898964 + } else { + var269 = -0.0455540419 + } + } else { + var269 = -0.466660827 + } + } else { + if (input[3]) >= (0.0250071939) { + if (input[2]) >= (0.0462601557) { + var269 = 0.301929533 + } else { + var269 = 0.0178715251 + } + } else { + if (input[8]) >= (0.155586153) { + var269 = 0.09360376 + } else { + var269 = 0.000614101067 + } + } + } + var var270 float64 + if (input[9]) >= (0.0169635899) { + if (input[6]) >= (0.0891260505) { + if (input[9]) >= (0.105838366) { + var270 = 0.40682134 + } else { + var270 = 0.0589930043 + } + } else { + if (input[3]) >= (0.00207781093) { + var270 = 0.00353533495 + } else { + var270 = 0.173592523 + } + } + } else { + if (input[9]) >= (0.0147980247) { + if (input[6]) >= (0.00206219708) { + var270 = -0.0557879917 + } else { + var270 = -0.267925382 + } + } else { + if (input[1]) >= (0.0043191053) { + var270 = -0.00647799391 + } else { + var270 = -0.269044667 + } + } + } + var var271 float64 + if (input[9]) >= (0.0452025533) { + if (input[4]) >= (0.472689092) { + if (input[8]) >= (0.0847102031) { + var271 = -0.0944264457 + } else { + var271 = 0.361354113 + } + } else { + if (input[6]) >= (0.124860764) { + var271 = 0.268893301 + } else { + var271 = -0.0154774208 + } + } + } else { + if (input[6]) >= (0.125071496) { + if (input[8]) >= (0.0631392598) { + var271 = 0.165061504 + } else { + var271 = -0.319522083 + } + } else { + if (input[5]) >= (0.145000011) { + var271 = -0.022164315 + } else { + var271 = 0.0143812271 + } + } + } + var var272 float64 + if (input[0]) >= (0.241353393) { + if (input[4]) >= (0.130952388) { + if (input[4]) >= (0.383753508) { + var272 = -0.0317161158 + } else { + var272 = -0.333876282 + } + } else { + if (input[4]) >= (0.0581232496) { + var272 = 0.195767567 + } else { + var272 = -0.213211983 + } + } + } else { + if (input[0]) >= (0.240150362) { + var272 = 0.363843769 + } else { + if (input[0]) >= (0.119849622) { + var272 = 0.0144968787 + } else { + var272 = -0.00320908171 + } + } + } + var var273 float64 + if (input[5]) >= (0.834999979) { + if (input[6]) >= (0.00701448042) { + var273 = -0.29334566 + } else { + var273 = -0.00610779645 + } + } else { + if (input[4]) >= (0.304621875) { + if (input[3]) >= (0.00740172435) { + var273 = 0.00171353039 + } else { + var273 = -0.123401321 + } + } else { + if (input[5]) >= (0.335000008) { + var273 = 0.147082999 + } else { + var273 = 0.00511494605 + } + } + } + var var274 float64 + if (input[0]) >= (0.0858646631) { + if (input[1]) >= (0.00685975607) { + if (input[3]) >= (0.00771413371) { + var274 = -0.0281877406 + } else { + var274 = 0.0508813336 + } + } else { + if (input[0]) >= (0.10781955) { + var274 = -0.206402183 + } else { + var274 = 0.038966015 + } + } + } else { + if (input[1]) >= (0.0073678866) { + if (input[4]) >= (0.262605071) { + var274 = 0.0447799861 + } else { + var274 = -0.00188021339 + } + } else { + if (input[0]) >= (0.0500751883) { + var274 = 0.255242974 + } else { + var274 = -0.0545441248 + } + } + } + var var275 float64 + if (input[9]) >= (0.0893223211) { + if (input[4]) >= (0.264005601) { + if (input[4]) >= (0.324229717) { + var275 = -0.00119861343 + } else { + var275 = -0.237305164 + } + } else { + if (input[4]) >= (0.119747899) { + var275 = 0.0799287111 + } else { + var275 = 0.00802524295 + } + } + } else { + if (input[9]) >= (0.0842693374) { + if (input[0]) >= (0.0206015036) { + var275 = -0.163760647 + } else { + var275 = -0.0120863421 + } + } else { + if (input[9]) >= (0.0839517266) { + var275 = 0.260037988 + } else { + var275 = -0.00282553094 + } + } + } + var var276 float64 + if (input[0]) >= (0.119849622) { + if (input[4]) >= (0.0581232496) { + if (input[4]) >= (0.0819327757) { + var276 = 0.0171305519 + } else { + var276 = 0.245078757 + } + } else { + if (input[3]) >= (0.00347208465) { + var276 = -0.13043505 + } else { + var276 = 0.206136584 + } + } + } else { + if (input[4]) >= (0.0581232496) { + if (input[4]) >= (0.0609243698) { + var276 = -0.0137817329 + } else { + var276 = -0.208883673 + } + } else { + if (input[4]) >= (0.0553221293) { + var276 = 0.324459016 + } else { + var276 = 0.00518289907 + } + } + } + var var277 float64 + if (input[1]) >= (0.210619926) { + if (input[4]) >= (0.0231092442) { + if (input[1]) >= (0.216717482) { + var277 = -0.115007833 + } else { + var277 = -0.404532522 + } + } else { + if (input[4]) >= (0.0147058824) { + var277 = 0.349731445 + } else { + var277 = 0.0117068496 + } + } + } else { + if (input[3]) >= (0.120433465) { + if (input[4]) >= (0.556722701) { + var277 = -0.0233467836 + } else { + var277 = 0.148738354 + } + } else { + if (input[3]) >= (0.115856387) { + var277 = -0.43056953 + } else { + var277 = 0.00190753571 + } + } + } + var var278 float64 + if (input[4]) >= (0.0511204489) { + if (input[4]) >= (0.0553221293) { + if (input[0]) >= (0.00225563906) { + var278 = -0.00110744836 + } else { + var278 = -0.277417451 + } + } else { + if (input[3]) >= (0.0077548055) { + var278 = 0.0284809731 + } else { + var278 = -0.188785464 + } + } + } else { + if (input[4]) >= (0.0483193286) { + if (input[5]) >= (0.00999999978) { + var278 = -0.48639968 + } else { + var278 = 0.189354524 + } + } else { + if (input[0]) >= (0.151127815) { + var278 = 0.162849143 + } else { + var278 = -0.000806786004 + } + } + } + var var279 float64 + if (input[0]) >= (0.19894737) { + if (input[4]) >= (0.223389357) { + if (input[8]) >= (0.0464857072) { + var279 = 0.0240415912 + } else { + var279 = 0.648341417 + } + } else { + if (input[8]) >= (0.0670731738) { + var279 = -0.278861433 + } else { + var279 = -0.0260252263 + } + } + } else { + if (input[7]) >= (0.0147518972) { + if (input[0]) >= (0.00556390965) { + var279 = 0.0185839478 + } else { + var279 = -0.298320442 + } + } else { + if (input[2]) >= (0.0171652753) { + var279 = -0.0328306034 + } else { + var279 = 0.00351690105 + } + } + } + var var280 float64 + if (input[4]) >= (0.397058845) { + if (input[1]) >= (0.0368394293) { + if (input[5]) >= (0.114999995) { + var280 = -0.243702769 + } else { + var280 = 0.139060497 + } + } else { + if (input[1]) >= (0.0205792673) { + var280 = -0.112578385 + } else { + var280 = 0.0817926079 + } + } + } else { + if (input[3]) >= (0.0921138227) { + if (input[4]) >= (0.032913167) { + var280 = -0.139802918 + } else { + var280 = 0.215990528 + } + } else { + if (input[0]) >= (0.16195488) { + var280 = -0.0478454418 + } else { + var280 = 0.00110611599 + } + } + } + var var281 float64 + if (input[6]) >= (0.280383527) { + var281 = 0.315250814 + } else { + if (input[7]) >= (0.302076995) { + if (input[6]) >= (0.0086853113) { + var281 = 0.00741528301 + } else { + var281 = -0.328243971 + } + } else { + if (input[7]) >= (0.19326055) { + var281 = 0.0983370841 + } else { + var281 = -0.000251510413 + } + } + } + var var282 float64 + if (input[8]) >= (0.124114871) { + if (input[4]) >= (0.0539215691) { + if (input[5]) >= (0.13499999) { + var282 = -0.00138184812 + } else { + var282 = 0.105560064 + } + } else { + if (input[4]) >= (0.0315126069) { + var282 = -0.273881167 + } else { + var282 = 0.0925220624 + } + } + } else { + if (input[4]) >= (0.210784316) { + if (input[5]) >= (0.00499999989) { + var282 = -0.0698221922 + } else { + var282 = 0.00428122655 + } + } else { + if (input[4]) >= (0.209383756) { + var282 = 0.267006308 + } else { + var282 = 0.00486279093 + } + } + } + var var283 float64 + if (input[4]) >= (0.542717099) { + if (input[0]) >= (0.0524812043) { + if (input[0]) >= (0.107518792) { + var283 = -0.0392902195 + } else { + var283 = -0.359901667 + } + } else { + if (input[0]) >= (0.0413533822) { + var283 = 0.375542104 + } else { + var283 = -0.100878187 + } + } + } else { + if (input[8]) >= (0.0685156062) { + if (input[4]) >= (0.0707282946) { + var283 = 0.0410153531 + } else { + var283 = -0.084355846 + } + } else { + if (input[4]) >= (0.314425766) { + var283 = -0.0653963834 + } else { + var283 = 0.00369753735 + } + } + } + var var284 float64 + if (input[8]) >= (0.00990034081) { + if (input[8]) >= (0.0102937315) { + if (input[4]) >= (0.0259103645) { + var284 = 0.00614601607 + } else { + var284 = -0.0229474008 + } + } else { + if (input[4]) >= (0.0273109246) { + var284 = -0.185654506 + } else { + var284 = 0.186602741 + } + } + } else { + if (input[1]) >= (0.0368394293) { + if (input[4]) >= (0.0301120449) { + var284 = 0.0901013836 + } else { + var284 = -0.108508043 + } + } else { + if (input[4]) >= (0.0259103645) { + var284 = -0.383383781 + } else { + var284 = 0.298784524 + } + } + } + var var285 float64 + if (input[5]) >= (0.114999995) { + if (input[4]) >= (0.488095224) { + if (input[2]) >= (0.138704598) { + var285 = 0.000357595476 + } else { + var285 = -0.27626887 + } + } else { + if (input[4]) >= (0.217787117) { + var285 = 0.105908342 + } else { + var285 = -0.00720146252 + } + } + } else { + if (input[4]) >= (0.0077030817) { + if (input[7]) >= (0.205514908) { + var285 = 0.15989548 + } else { + var285 = -0.00796319637 + } + } else { + if (input[3]) >= (0.00307960343) { + var285 = 0.314555317 + } else { + var285 = 0.0617510714 + } + } + } + var var286 float64 + if (input[8]) >= (0.0182926822) { + if (input[4]) >= (0.0259103645) { + if (input[4]) >= (0.0287114847) { + var286 = -0.00737537397 + } else { + var286 = 0.191063866 + } + } else { + if (input[4]) >= (0.021708684) { + var286 = -0.276225835 + } else { + var286 = -0.00879602693 + } + } + } else { + if (input[4]) >= (0.0819327757) { + if (input[4]) >= (0.0833333358) { + var286 = 0.0671397597 + } else { + var286 = 1.05702651 + } + } else { + if (input[4]) >= (0.042717088) { + var286 = -0.157391191 + } else { + var286 = 0.0110585457 + } + } + } + var var287 float64 + if (input[0]) >= (0.00105263153) { + if (input[7]) >= (0.223716855) { + if (input[5]) >= (0.0649999976) { + var287 = -0.232259572 + } else { + var287 = 0.0764968619 + } + } else { + if (input[7]) >= (0.205501288) { + var287 = 0.239033788 + } else { + var287 = -0.00222767936 + } + } + } else { + if (input[6]) >= (0.00311587448) { + if (input[6]) >= (0.0096637262) { + var287 = 0.0219274089 + } else { + var287 = 0.205697134 + } + } else { + if (input[0]) >= (0.000751879707) { + var287 = -0.130113542 + } else { + var287 = 0.0364647619 + } + } + } + var var288 float64 + if (input[1]) >= (0.0205792673) { + if (input[8]) >= (0.0295698922) { + if (input[0]) >= (0.0861654133) { + var288 = -0.00655728159 + } else { + var288 = 0.0351217128 + } + } else { + if (input[0]) >= (0.0272180438) { + var288 = -0.0741885602 + } else { + var288 = 0.00714864954 + } + } + } else { + if (input[8]) >= (0.0277340673) { + if (input[5]) >= (0.0350000001) { + var288 = 0.0232206266 + } else { + var288 = -0.066541709 + } + } else { + if (input[0]) >= (0.0500751883) { + var288 = 0.160642028 + } else { + var288 = -0.00486443425 + } + } + } + var var289 float64 + if (input[0]) >= (0.12676692) { + if (input[0]) >= (0.128270686) { + if (input[3]) >= (0.00389328972) { + var289 = -0.00172032707 + } else { + var289 = 0.096991621 + } + } else { + if (input[4]) >= (0.291316539) { + var289 = 0.24938488 + } else { + var289 = 0.0143633112 + } + } + } else { + if (input[4]) >= (0.415266097) { + if (input[0]) >= (0.0610526316) { + var289 = -0.0875769258 + } else { + var289 = 0.0972131938 + } + } else { + if (input[5]) >= (0.185000002) { + var289 = 0.0851869136 + } else { + var289 = -0.00313443271 + } + } + } + var var290 float64 + if (input[6]) >= (0.220910966) { + var290 = -0.236054644 + } else { + if (input[9]) >= (0.0271561816) { + if (input[0]) >= (0.121954888) { + var290 = -0.0664036199 + } else { + var290 = -0.00422644615 + } + } else { + if (input[0]) >= (0.261202991) { + var290 = -0.156563699 + } else { + var290 = 0.00901314151 + } + } + } + var var291 float64 + if (input[8]) >= (0.0670731738) { + if (input[8]) >= (0.067204304) { + if (input[0]) >= (0.121353388) { + var291 = -0.00349583244 + } else { + var291 = 0.0537141524 + } + } else { + var291 = 0.429644585 + } + } else { + if (input[4]) >= (0.457983196) { + if (input[0]) >= (0.121654138) { + var291 = 0.50777626 + } else { + var291 = 0.0497585908 + } + } else { + if (input[4]) >= (0.321428597) { + var291 = -0.0603806973 + } else { + var291 = 0.00396019779 + } + } + } + var var292 float64 + if (input[4]) >= (0.0637254938) { + if (input[4]) >= (0.0987394974) { + if (input[0]) >= (0.00255639106) { + var292 = 0.000783656084 + } else { + var292 = -0.277013123 + } + } else { + if (input[4]) >= (0.0945378169) { + var292 = -0.265633702 + } else { + var292 = -0.0137670999 + } + } + } else { + if (input[0]) >= (0.0660150349) { + if (input[0]) >= (0.155939847) { + var292 = 0.0909797177 + } else { + var292 = -0.124006718 + } + } else { + if (input[0]) >= (0.0160902254) { + var292 = 0.111930095 + } else { + var292 = -2.20861839e-05 + } + } + } + var var293 float64 + if (input[0]) >= (0.180300742) { + if (input[8]) >= (0.0557959601) { + if (input[4]) >= (0.335434198) { + var293 = 0.0990245491 + } else { + var293 = -0.15261814 + } + } else { + if (input[3]) >= (0.0128555335) { + var293 = 0.293129385 + } else { + var293 = -0.0233459212 + } + } + } else { + if (input[0]) >= (0.179398507) { + var293 = 0.295414746 + } else { + if (input[4]) >= (0.174369752) { + var293 = -0.00793942437 + } else { + var293 = 0.0102052158 + } + } + } + var var294 float64 + if (input[4]) >= (0.0987394974) { + if (input[4]) >= (0.109943978) { + if (input[4]) >= (0.115546219) { + var294 = 0.00179638306 + } else { + var294 = -0.0838018507 + } + } else { + if (input[5]) >= (0.00499999989) { + var294 = -0.113575064 + } else { + var294 = 0.105564333 + } + } + } else { + if (input[4]) >= (0.0945378169) { + if (input[4]) >= (0.0973389372) { + var294 = -0.040219903 + } else { + var294 = -0.249156326 + } + } else { + if (input[4]) >= (0.0903361365) { + var294 = 0.0972724035 + } else { + var294 = -0.0127365664 + } + } + } + var var295 float64 + if (input[0]) >= (0.00285714283) { + if (input[4]) >= (0.021708684) { + if (input[2]) >= (0.001489499) { + var295 = 0.00244264281 + } else { + var295 = 0.0796177238 + } + } else { + if (input[5]) >= (0.00499999989) { + var295 = 0.0404901877 + } else { + var295 = -0.123894282 + } + } + } else { + if (input[4]) >= (0.0161064435) { + if (input[4]) >= (0.0231092442) { + var295 = -0.0788872316 + } else { + var295 = 0.176595107 + } + } else { + if (input[0]) >= (0.00255639106) { + var295 = 0.119972676 + } else { + var295 = -0.300634563 + } + } + } + var var296 float64 + if (input[6]) >= (0.280383527) { + var296 = 0.275115877 + } else { + if (input[2]) >= (0.00455958862) { + if (input[2]) >= (0.00547791272) { + var296 = 1.76011042e-06 + } else { + var296 = 0.0744212195 + } + } else { + if (input[4]) >= (0.357843161) { + var296 = 0.190605119 + } else { + var296 = -0.018577667 + } + } + } + var var297 float64 + if (input[4]) >= (0.273809552) { + if (input[5]) >= (0.375) { + if (input[4]) >= (0.322829127) { + var297 = -0.428333312 + } else { + var297 = -0.00437406916 + } + } else { + if (input[7]) >= (0.00015584135) { + var297 = 0.0112625612 + } else { + var297 = 0.148052529 + } + } + } else { + if (input[5]) >= (0.114999995) { + if (input[4]) >= (0.217787117) { + var297 = 0.219511583 + } else { + var297 = -0.00656802673 + } + } else { + if (input[4]) >= (0.210784316) { + var297 = -0.0562036373 + } else { + var297 = -0.00174245262 + } + } + } + var var298 float64 + if (input[3]) >= (0.0026850889) { + if (input[8]) >= (0.00976921059) { + if (input[8]) >= (0.0160634667) { + var298 = -0.00133843452 + } else { + var298 = 0.0378922895 + } + } else { + if (input[0]) >= (0.00526315812) { + var298 = 0.0529606342 + } else { + var298 = -0.115417369 + } + } + } else { + if (input[0]) >= (0.0230075195) { + if (input[0]) >= (0.0272180438) { + var298 = -0.0736679211 + } else { + var298 = -0.299362361 + } + } else { + if (input[6]) >= (0.00215251232) { + var298 = 0.0237008631 + } else { + var298 = -0.124940313 + } + } + } + var var299 float64 + if (input[1]) >= (0.0134654474) { + if (input[5]) >= (0.175000012) { + if (input[0]) >= (0.0720300749) { + var299 = 0.012999312 + } else { + var299 = 0.228289902 + } + } else { + if (input[5]) >= (0.145000011) { + var299 = -0.0918691307 + } else { + var299 = -0.00351997488 + } + } + } else { + if (input[9]) >= (0.0318049267) { + if (input[5]) >= (0.00499999989) { + var299 = 0.03014745 + } else { + var299 = -0.178247482 + } + } else { + if (input[9]) >= (0.0192157775) { + var299 = 0.0809756666 + } else { + var299 = 0.00406664331 + } + } + } + var var300 float64 + if (input[8]) >= (0.0108182533) { + if (input[0]) >= (0.00285714283) { + if (input[8]) >= (0.0131786) { + var300 = 0.000734207686 + } else { + var300 = -0.0853739753 + } + } else { + if (input[4]) >= (0.0147058824) { + var300 = 0.132203296 + } else { + var300 = -0.205360964 + } + } + } else { + if (input[4]) >= (0.0273109246) { + if (input[4]) >= (0.0301120449) { + var300 = 0.00826729182 + } else { + var300 = -0.405049235 + } + } else { + if (input[0]) >= (0.00375939859) { + var300 = 0.178201303 + } else { + var300 = -0.0850277692 + } + } + } + var var301 float64 + if (input[0]) >= (0.00135338353) { + if (input[8]) >= (0.0116050355) { + if (input[0]) >= (0.00466165412) { + var301 = -0.0022700252 + } else { + var301 = 0.108916767 + } + } else { + if (input[4]) >= (0.021708684) { + var301 = 0.0140152695 + } else { + var301 = -0.131548747 + } + } + } else { + if (input[8]) >= (0.00911355857) { + if (input[4]) >= (0.105042025) { + var301 = -0.217132181 + } else { + var301 = 0.254907668 + } + } else { + if (input[8]) >= (0.00845790748) { + var301 = -0.337023497 + } else { + var301 = 0.0984557196 + } + } + } + var var302 float64 + if (input[5]) >= (0.754999995) { + if (input[2]) >= (0.100029469) { + var302 = -0.329162031 + } else { + if (input[2]) >= (0.0375732146) { + var302 = 0.112829573 + } else { + var302 = -0.178680271 + } + } + } else { + if (input[4]) >= (0.667366982) { + if (input[3]) >= (0.16188395) { + var302 = -0.0388491377 + } else { + var302 = -0.232922778 + } + } else { + if (input[4]) >= (0.0147058824) { + var302 = -0.00368232257 + } else { + var302 = 0.0303132683 + } + } + } + var var303 float64 + if (input[6]) >= (0.108122349) { + if (input[2]) >= (0.0758124962) { + var303 = 0.287597597 + } else { + if (input[2]) >= (0.0194421671) { + var303 = -0.269043088 + } else { + var303 = 0.000512624334 + } + } + } else { + if (input[6]) >= (0.102312073) { + if (input[1]) >= (0.0370934978) { + var303 = 0.430314153 + } else { + var303 = -0.0107942456 + } + } else { + if (input[6]) >= (0.0938073844) { + var303 = -0.199522749 + } else { + var303 = -0.000882540538 + } + } + } + var var304 float64 + if (input[2]) >= (0.000881086686) { + if (input[2]) >= (0.000891897595) { + if (input[0]) >= (0.00105263153) { + var304 = 0.0022803715 + } else { + var304 = 0.119134672 + } + } else { + var304 = 0.431203514 + } + } else { + if (input[4]) >= (0.0259103645) { + if (input[2]) >= (0.000742146862) { + var304 = 0.00315292622 + } else { + var304 = 0.255445659 + } + } else { + if (input[7]) >= (0.000133897585) { + var304 = -0.421744078 + } else { + var304 = -0.0681169182 + } + } + } + var var305 float64 + if (input[6]) >= (0.152587533) { + if (input[0]) >= (0.0299248137) { + if (input[8]) >= (0.0379622355) { + var305 = 0.0903427824 + } else { + var305 = 0.550862551 + } + } else { + var305 = -0.152316093 + } + } else { + if (input[6]) >= (0.126019806) { + if (input[5]) >= (0.00499999989) { + var305 = 0.100360774 + } else { + var305 = -0.330292165 + } + } else { + if (input[6]) >= (0.11927627) { + var305 = 0.256729245 + } else { + var305 = -0.00105778396 + } + } + } + var var306 float64 + if (input[1]) >= (0.0439532511) { + if (input[7]) >= (0.001334709) { + if (input[7]) >= (0.00134385226) { + var306 = 0.00492482539 + } else { + var306 = 0.371945381 + } + } else { + if (input[7]) >= (0.000708499108) { + var306 = -0.122599408 + } else { + var306 = -0.0302312654 + } + } + } else { + if (input[3]) >= (0.0227870308) { + if (input[9]) >= (0.0430369861) { + var306 = 0.258989573 + } else { + var306 = 0.0332327597 + } + } else { + if (input[9]) >= (0.135780901) { + var306 = 0.0378570706 + } else { + var306 = -0.0013929758 + } + } + } + var var307 float64 + if (input[0]) >= (0.084360905) { + if (input[0]) >= (0.119849622) { + if (input[0]) >= (0.12105263) { + var307 = -0.0116397366 + } else { + var307 = 0.0986655876 + } + } else { + if (input[3]) >= (0.00847342145) { + var307 = -0.0998042598 + } else { + var307 = -0.00379005331 + } + } + } else { + if (input[1]) >= (0.0073678866) { + if (input[7]) >= (0.0664757788) { + var307 = -0.0880032554 + } else { + var307 = 0.00207109633 + } + } else { + if (input[3]) >= (0.00428958377) { + var307 = -0.0312897228 + } else { + var307 = 0.233685642 + } + } + } + var var308 float64 + if (input[8]) >= (0.154405981) { + if (input[5]) >= (0.375) { + if (input[3]) >= (0.0235890262) { + var308 = -0.154792935 + } else { + var308 = 0.140004575 + } + } else { + if (input[0]) >= (0.125263155) { + var308 = 0.0532684103 + } else { + var308 = 0.237360284 + } + } + } else { + if (input[8]) >= (0.151914507) { + var308 = -0.296536416 + } else { + if (input[8]) >= (0.150734335) { + var308 = 0.272759289 + } else { + var308 = -0.00213638204 + } + } + } + var var309 float64 + if (input[4]) >= (0.0273109246) { + if (input[0]) >= (0.00345864659) { + if (input[8]) >= (0.0109493835) { + var309 = 0.00757080689 + } else { + var309 = -0.14336656 + } + } else { + if (input[8]) >= (0.0129163386) { + var309 = -0.0702465698 + } else { + var309 = 0.376838267 + } + } + } else { + if (input[8]) >= (0.0108182533) { + if (input[4]) >= (0.021708684) { + var309 = -0.146462843 + } else { + var309 = 0.00117639243 + } + } else { + if (input[0]) >= (0.00375939859) { + var309 = 0.113502629 + } else { + var309 = -0.0748205706 + } + } + } + var var310 float64 + if (input[3]) >= (0.0692812949) { + if (input[4]) >= (0.157563031) { + if (input[2]) >= (0.119559325) { + var310 = 0.01659289 + } else { + var310 = 0.156964093 + } + } else { + if (input[4]) >= (0.12114846) { + var310 = -0.290744036 + } else { + var310 = 0.0214160979 + } + } + } else { + if (input[3]) >= (0.0687797666) { + var310 = -0.386910588 + } else { + if (input[4]) >= (0.574929953) { + var310 = -0.0977590233 + } else { + var310 = 0.00275972066 + } + } + } + var var311 float64 + if (input[8]) >= (0.00845790748) { + if (input[8]) >= (0.00990034081) { + if (input[8]) >= (0.010031471) { + var311 = 0.000534939638 + } else { + var311 = 0.155808866 + } + } else { + if (input[5]) >= (0.00499999989) { + var311 = -0.342671961 + } else { + var311 = -0.0174334738 + } + } + } else { + if (input[0]) >= (0.0514285713) { + var311 = -0.469604254 + } else { + if (input[0]) >= (0.000451127824) { + var311 = 0.12268471 + } else { + var311 = -0.256605357 + } + } + } + var var312 float64 + if (input[3]) >= (0.121799268) { + if (input[5]) >= (0.0350000001) { + if (input[3]) >= (0.136228293) { + var312 = 0.124041378 + } else { + var312 = 0.375345379 + } + } else { + if (input[7]) >= (0.00109800091) { + var312 = 0.147618979 + } else { + var312 = -0.166997448 + } + } + } else { + if (input[3]) >= (0.116484001) { + var312 = -0.271234095 + } else { + if (input[6]) >= (0.0952674896) { + var312 = -0.0821127146 + } else { + var312 = -0.00174526277 + } + } + } + var var313 float64 + if (input[6]) >= (0.0175964125) { + if (input[7]) >= (0.00246196822) { + if (input[7]) >= (0.0025513689) { + var313 = 0.0258625131 + } else { + var313 = 0.326643854 + } + } else { + if (input[9]) >= (0.00552940834) { + var313 = -0.00833026413 + } else { + var313 = -0.0979755446 + } + } + } else { + if (input[6]) >= (0.0167233646) { + if (input[3]) >= (0.0231126584) { + var313 = -0.254882157 + } else { + var313 = -0.0369429514 + } + } else { + if (input[8]) >= (0.0289142411) { + var313 = 0.0071671647 + } else { + var313 = -0.0133674694 + } + } + } + var var314 float64 + if (input[6]) >= (0.147183672) { + if (input[2]) >= (0.0194415655) { + if (input[2]) >= (0.0517240539) { + var314 = 0.230417356 + } else { + var314 = -0.231224641 + } + } else { + if (input[2]) >= (0.00997363776) { + var314 = 0.383196801 + } else { + var314 = 0.0273840316 + } + } + } else { + if (input[3]) >= (0.0024339417) { + if (input[4]) >= (0.042717088) { + var314 = -0.00221866998 + } else { + var314 = 0.0152277462 + } + } else { + if (input[2]) >= (0.00104345009) { + var314 = -0.0807774737 + } else { + var314 = 0.171384931 + } + } + } + var var315 float64 + if (input[6]) >= (0.00152030587) { + if (input[6]) >= (0.00155041087) { + if (input[0]) >= (0.00105263153) { + var315 = -0.00207328727 + } else { + var315 = 0.0962062925 + } + } else { + if (input[3]) >= (0.0114391446) { + var315 = -0.289932787 + } else { + var315 = -0.0306339636 + } + } + } else { + if (input[9]) >= (0.166243181) { + if (input[8]) >= (0.0148177287) { + var315 = 0.0575389415 + } else { + var315 = -0.218524292 + } + } else { + if (input[3]) >= (0.00271762628) { + var315 = 0.0834022164 + } else { + var315 = -0.112467945 + } + } + } + var var316 float64 + if (input[4]) >= (0.0119047621) { + if (input[4]) >= (0.0147058824) { + if (input[4]) >= (0.0161064435) { + var316 = -0.000123649748 + } else { + var316 = -0.182855487 + } + } else { + if (input[8]) >= (0.0108182533) { + var316 = 0.182439417 + } else { + var316 = -0.178036273 + } + } + } else { + if (input[8]) >= (0.0137031209) { + if (input[5]) >= (0.00999999978) { + var316 = -0.0231398046 + } else { + var316 = -0.822692752 + } + } else { + if (input[4]) >= (0.00910364185) { + var316 = 0.232032955 + } else { + var316 = -0.140776977 + } + } + } + var var317 float64 + if (input[7]) >= (0.209909767) { + if (input[4]) >= (0.117647059) { + if (input[3]) >= (0.0122312242) { + var317 = -0.114009991 + } else { + var317 = 0.274085671 + } + } else { + if (input[3]) >= (0.00567140151) { + var317 = -0.445832938 + } else { + var317 = -0.0413070843 + } + } + } else { + if (input[7]) >= (0.205834329) { + var317 = 0.328243375 + } else { + if (input[4]) >= (0.0665266141) { + var317 = -0.00430549029 + } else { + var317 = 0.0111220134 + } + } + } + var var318 float64 + if (input[9]) >= (0.0526520982) { + if (input[0]) >= (0.0524812043) { + if (input[9]) >= (0.131420895) { + var318 = -0.296413094 + } else { + var318 = 0.0586084202 + } + } else { + if (input[0]) >= (0.0311278198) { + var318 = -0.0738035738 + } else { + var318 = -0.00510699302 + } + } + } else { + if (input[9]) >= (0.0521901101) { + if (input[3]) >= (0.00305825099) { + var318 = 0.130673692 + } else { + var318 = 0.379126787 + } + } else { + if (input[0]) >= (0.0509774461) { + var318 = -0.00904626399 + } else { + var318 = 0.0227523725 + } + } + } + var var319 float64 + if (input[4]) >= (0.510504246) { + if (input[1]) >= (0.0383638218) { + if (input[1]) >= (0.0429369919) { + var319 = -0.0233829785 + } else { + var319 = 0.214847252 + } + } else { + if (input[3]) >= (0.0251818262) { + var319 = 0.126049891 + } else { + var319 = -0.157557815 + } + } + } else { + if (input[7]) >= (0.0324190632) { + if (input[9]) >= (0.0324112847) { + var319 = -0.0276937559 + } else { + var319 = 0.0383203551 + } + } else { + if (input[9]) >= (0.0303900912) { + var319 = 0.00526065566 + } else { + var319 = -0.0151233803 + } + } + } + var var320 float64 + if (input[3]) >= (0.00386202359) { + if (input[8]) >= (0.0155389458) { + if (input[8]) >= (0.0278651975) { + var320 = 0.0123636993 + } else { + var320 = -0.0202348623 + } + } else { + if (input[4]) >= (0.0623249337) { + var320 = 0.237750843 + } else { + var320 = 0.00274135731 + } + } + } else { + if (input[3]) >= (0.00336379651) { + if (input[6]) >= (0.0175663065) { + var320 = 0.0361665711 + } else { + var320 = -0.078740567 + } + } else { + if (input[6]) >= (0.0135021228) { + var320 = -0.0402578078 + } else { + var320 = 0.0149596985 + } + } + } + var var321 float64 + if (input[3]) >= (0.300652921) { + var321 = -0.234236732 + } else { + if (input[7]) >= (0.106107637) { + if (input[4]) >= (0.12114846) { + var321 = -0.0730502829 + } else { + var321 = 0.0636460632 + } + } else { + if (input[7]) >= (0.0974752083) { + var321 = 0.0991552472 + } else { + var321 = 0.000620873005 + } + } + } + var var322 float64 + if (input[6]) >= (0.283710152) { + var322 = -0.285064638 + } else { + if (input[6]) >= (0.0891411006) { + if (input[6]) >= (0.0928891897) { + var322 = 0.0203629229 + } else { + var322 = 0.269062132 + } + } else { + if (input[6]) >= (0.0853629112) { + var322 = -0.185597047 + } else { + var322 = -0.0065480792 + } + } + } + var var323 float64 + if (input[8]) >= (0.0135719907) { + if (input[8]) >= (0.0142276427) { + if (input[0]) >= (0.00466165412) { + var323 = 0.00317906775 + } else { + var323 = 0.0785248652 + } + } else { + if (input[2]) >= (0.0188317522) { + var323 = 0.493960142 + } else { + var323 = 0.0676818714 + } + } + } else { + if (input[0]) >= (0.0166917294) { + if (input[0]) >= (0.0178947374) { + var323 = 0.0673472509 + } else { + var323 = 0.639036536 + } + } else { + if (input[0]) >= (0.00766917318) { + var323 = -0.170730203 + } else { + var323 = -0.0135729183 + } + } + } + var var324 float64 + if (input[7]) >= (0.0578122661) { + if (input[6]) >= (0.0245506819) { + if (input[4]) >= (0.272408962) { + var324 = 0.222112909 + } else { + var324 = 0.0396600738 + } + } else { + if (input[6]) >= (0.0214498602) { + var324 = -0.196001694 + } else { + var324 = 0.012227443 + } + } + } else { + if (input[7]) >= (0.0572140925) { + if (input[2]) >= (0.0645189285) { + var324 = -0.475988448 + } else { + var324 = -0.0710307807 + } + } else { + if (input[6]) >= (0.0281331837) { + var324 = -0.0221564099 + } else { + var324 = 0.00102217065 + } + } + } + var var325 float64 + if (input[2]) >= (0.148706853) { + if (input[4]) >= (0.336834729) { + if (input[8]) >= (0.0859559402) { + var325 = 0.0162247699 + } else { + var325 = 0.395905286 + } + } else { + if (input[5]) >= (0.215000004) { + var325 = 0.0797636136 + } else { + var325 = -0.16091232 + } + } + } else { + if (input[7]) >= (0.140486002) { + var325 = 0.291054696 + } else { + if (input[5]) >= (0.215000004) { + var325 = -0.0436242707 + } else { + var325 = 0.00334614841 + } + } + } + var var326 float64 + if (input[3]) >= (0.00490474189) { + if (input[3]) >= (0.0049510058) { + if (input[4]) >= (0.200980395) { + var326 = -0.0128034484 + } else { + var326 = 0.0162679162 + } + } else { + if (input[8]) >= (0.017571466) { + var326 = 0.358248651 + } else { + var326 = -0.0610035919 + } + } + } else { + if (input[8]) >= (0.0224888548) { + if (input[4]) >= (0.052521009) { + var326 = -0.0725589767 + } else { + var326 = 0.010818583 + } + } else { + if (input[5]) >= (0.0949999988) { + var326 = 0.30049485 + } else { + var326 = 0.00246530049 + } + } + } + var var327 float64 + if (input[0]) >= (0.207669169) { + if (input[4]) >= (0.179971993) { + if (input[0]) >= (0.241052628) { + var327 = -0.165422112 + } else { + var327 = 0.223827943 + } + } else { + if (input[4]) >= (0.135154068) { + var327 = -0.316963583 + } else { + var327 = 0.0466178283 + } + } + } else { + if (input[0]) >= (0.180300742) { + if (input[5]) >= (0.0549999997) { + var327 = -0.014636687 + } else { + var327 = -0.186242878 + } + } else { + if (input[0]) >= (0.179398507) { + var327 = 0.258977711 + } else { + var327 = -0.00275184656 + } + } + } + var var328 float64 + if (input[1]) >= (0.083079271) { + if (input[0]) >= (0.0136842104) { + if (input[0]) >= (0.03924812) { + var328 = -0.0526077934 + } else { + var328 = 0.0941067636 + } + } else { + if (input[4]) >= (0.0371148475) { + var328 = -0.231615767 + } else { + var328 = 0.00467879837 + } + } + } else { + if (input[1]) >= (0.0769817084) { + if (input[2]) >= (0.0233092587) { + var328 = 0.168643355 + } else { + var328 = -0.0271485895 + } + } else { + if (input[1]) >= (0.0713922754) { + var328 = -0.0551071838 + } else { + var328 = 0.00544936862 + } + } + } + var var329 float64 + if (input[4]) >= (0.0553221293) { + if (input[4]) >= (0.0637254938) { + if (input[9]) >= (0.220656604) { + var329 = -0.149859786 + } else { + var329 = -0.000207438352 + } + } else { + if (input[0]) >= (0.0251127817) { + var329 = 0.2102997 + } else { + var329 = -0.0563225113 + } + } + } else { + if (input[4]) >= (0.052521009) { + if (input[1]) >= (0.044969514) { + var329 = 0.0503511392 + } else { + var329 = -0.263940424 + } + } else { + if (input[5]) >= (0.0350000001) { + var329 = -0.0535254814 + } else { + var329 = 0.00085063529 + } + } + } + var var330 float64 + if (input[0]) >= (0.19894737) { + if (input[8]) >= (0.0670731738) { + if (input[8]) >= (0.18364805) { + var330 = 0.102626979 + } else { + var330 = -0.184893698 + } + } else { + if (input[7]) >= (0.0231181607) { + var330 = -0.0724921003 + } else { + var330 = 0.0896771699 + } + } + } else { + if (input[0]) >= (0.19834587) { + var330 = 0.456023514 + } else { + if (input[1]) >= (0.0144817075) { + var330 = -0.00396970008 + } else { + var330 = 0.0276505072 + } + } + } + var var331 float64 + if (input[7]) >= (0.0104277572) { + if (input[0]) >= (0.00676691718) { + if (input[0]) >= (0.0717293248) { + var331 = -0.00187411997 + } else { + var331 = 0.0378329456 + } + } else { + if (input[0]) >= (0.00406015012) { + var331 = -0.216612741 + } else { + var331 = 0.159773543 + } + } + } else { + if (input[5]) >= (0.125) { + if (input[0]) >= (0.00556390965) { + var331 = 0.0993390158 + } else { + var331 = -0.439337164 + } + } else { + if (input[7]) >= (0.010017734) { + var331 = -0.143345103 + } else { + var331 = -0.00548424665 + } + } + } + var var332 float64 + if (input[2]) >= (0.0151520493) { + if (input[9]) >= (0.00402795058) { + if (input[2]) >= (0.0153550534) { + var332 = -0.00830756128 + } else { + var332 = -0.148486242 + } + } else { + if (input[9]) >= (0.00362371141) { + var332 = 0.212815896 + } else { + var332 = 0.0243317522 + } + } + } else { + if (input[4]) >= (0.269607842) { + if (input[3]) >= (0.00739435293) { + var332 = 0.190716013 + } else { + var332 = -0.0619829744 + } + } else { + if (input[0]) >= (0.0738345832) { + var332 = 0.0800450072 + } else { + var332 = -0.000963165017 + } + } + } + var var333 float64 + if (input[1]) >= (0.151676834) { + if (input[4]) >= (0.0273109246) { + if (input[4]) >= (0.157563031) { + var333 = 0.102568574 + } else { + var333 = -0.0752707124 + } + } else { + if (input[1]) >= (0.187754065) { + var333 = 0.297112525 + } else { + var333 = 0.0485113598 + } + } + } else { + if (input[1]) >= (0.144054875) { + if (input[1]) >= (0.146595523) { + var333 = -0.00665780529 + } else { + var333 = -0.313791037 + } + } else { + if (input[1]) >= (0.133892283) { + var333 = 0.0920097828 + } else { + var333 = -0.000245233008 + } + } + } + var var334 float64 + if (input[8]) >= (0.00753999501) { + if (input[8]) >= (0.00806451589) { + if (input[4]) >= (0.174369752) { + var334 = -0.00665227557 + } else { + var334 = 0.00461732922 + } + } else { + if (input[4]) >= (0.0259103645) { + var334 = 0.294704676 + } else { + var334 = -0.0381972678 + } + } + } else { + if (input[7]) >= (0.000374466239) { + if (input[1]) >= (0.152693093) { + var334 = -0.04692946 + } else { + var334 = -0.275813609 + } + } else { + if (input[2]) >= (0.00777062029) { + var334 = 0.446210444 + } else { + var334 = -0.141434297 + } + } + } + var var335 float64 + if (input[2]) >= (0.000963569735) { + if (input[6]) >= (0.00118915015) { + if (input[6]) >= (0.00149020087) { + var335 = -0.00233240426 + } else { + var335 = 0.0454745479 + } + } else { + if (input[0]) >= (0.00315789459) { + var335 = -0.119568557 + } else { + var335 = 0.0802512243 + } + } + } else { + if (input[9]) >= (0.0697311834) { + if (input[0]) >= (0.00315789459) { + var335 = -0.329945296 + } else { + var335 = 0.00327738537 + } + } else { + if (input[6]) >= (0.00218261732) { + var335 = 0.071402818 + } else { + var335 = -0.202553555 + } + } + } + var var336 float64 + if (input[4]) >= (0.00910364185) { + if (input[4]) >= (0.0119047621) { + if (input[8]) >= (0.00740886433) { + var336 = 0.00493809395 + } else { + var336 = -0.129449144 + } + } else { + if (input[8]) >= (0.0272095464) { + var336 = 0.277629554 + } else { + var336 = -0.170581639 + } + } + } else { + if (input[8]) >= (0.0152766854) { + if (input[5]) >= (0.145000011) { + var336 = -0.056375768 + } else { + var336 = 0.277535498 + } + } else { + if (input[8]) >= (0.00740886433) { + var336 = -0.306932211 + } else { + var336 = 0.260632843 + } + } + } + var var337 float64 + if (input[6]) >= (0.00633711647) { + if (input[7]) >= (5.01861941e-05) { + if (input[6]) >= (0.00669837743) { + var337 = 0.00292044878 + } else { + var337 = 0.0682330281 + } + } else { + if (input[7]) >= (4.16525145e-05) { + var337 = -0.228818059 + } else { + var337 = -0.0386682451 + } + } + } else { + if (input[7]) >= (0.0157444458) { + if (input[4]) >= (0.0777310953) { + var337 = 0.0370208323 + } else { + var337 = -0.0553130358 + } + } else { + if (input[9]) >= (0.0670314431) { + var337 = 0.00779267587 + } else { + var337 = -0.0409367457 + } + } + } + var var338 float64 + if (input[8]) >= (0.261605024) { + if (input[1]) >= (0.0287093502) { + if (input[5]) >= (0.340000004) { + var338 = 0.437235624 + } else { + var338 = 0.0977231488 + } + } else { + var338 = 0.0279979389 + } + } else { + if (input[3]) >= (0.0397511609) { + if (input[3]) >= (0.0460356846) { + var338 = 0.0101555362 + } else { + var338 = 0.131362483 + } + } else { + if (input[3]) >= (0.0346926302) { + var338 = -0.0722377673 + } else { + var338 = 2.45762603e-05 + } + } + } + var var339 float64 + if (input[9]) >= (0.405263782) { + if (input[8]) >= (0.00976921059) { + if (input[7]) >= (0.00422295509) { + var339 = 0.0709616169 + } else { + var339 = 0.250192702 + } + } else { + if (input[0]) >= (0.00105263153) { + var339 = -0.19661434 + } else { + var339 = 0.0729795322 + } + } + } else { + if (input[9]) >= (0.389700592) { + var339 = -0.255369782 + } else { + if (input[2]) >= (0.0738000721) { + var339 = -0.0208027977 + } else { + var339 = 0.00486319559 + } + } + } + var var340 float64 + if (input[8]) >= (0.00806451589) { + if (input[9]) >= (0.556954324) { + if (input[9]) >= (0.715733528) { + var340 = 0.0431087986 + } else { + var340 = -0.179263473 + } + } else { + if (input[9]) >= (0.531429529) { + var340 = 0.342517018 + } else { + var340 = 0.00146163662 + } + } + } else { + if (input[7]) >= (0.0115326662) { + var340 = -0.287440032 + } else { + if (input[4]) >= (0.0294117648) { + var340 = 0.234791487 + } else { + var340 = 0.0580950007 + } + } + } + var var341 float64 + if (input[0]) >= (0.273834586) { + if (input[4]) >= (0.101540618) { + var341 = -0.250225365 + } else { + if (input[4]) >= (0.065126054) { + var341 = 0.362618387 + } else { + var341 = 0.0516042672 + } + } + } else { + if (input[0]) >= (0.259097755) { + if (input[4]) >= (0.0616246536) { + var341 = -0.0120407734 + } else { + var341 = -0.309830874 + } + } else { + if (input[5]) >= (0.234999999) { + var341 = 0.0427041501 + } else { + var341 = -0.000212861472 + } + } + } + var var342 float64 + if (input[6]) >= (0.0206370242) { + if (input[6]) >= (0.0225637481) { + if (input[7]) >= (0.00415204419) { + var342 = 0.0120116184 + } else { + var342 = -0.0383394063 + } + } else { + if (input[6]) >= (0.0223530121) { + var342 = -0.298264861 + } else { + var342 = -0.059204381 + } + } + } else { + if (input[6]) >= (0.0204864983) { + if (input[8]) >= (0.0207185932) { + var342 = 0.30904603 + } else { + var342 = 0.0132600693 + } + } else { + if (input[5]) >= (0.0649999976) { + var342 = -0.021893939 + } else { + var342 = 0.00636848435 + } + } + } + var var343 float64 + if (input[9]) >= (0.686700583) { + if (input[2]) >= (0.00415578252) { + var343 = 0.338708818 + } else { + var343 = 0.00430314057 + } + } else { + if (input[9]) >= (0.556954324) { + if (input[6]) >= (0.00428997213) { + var343 = -0.273895711 + } else { + var343 = -0.0362647176 + } + } else { + if (input[9]) >= (0.535038829) { + var343 = 0.241655722 + } else { + var343 = 0.00084551709 + } + } + } + var var344 float64 + if (input[4]) >= (0.139355749) { + if (input[4]) >= (0.14915967) { + if (input[0]) >= (0.0206015036) { + var344 = -0.00627159374 + } else { + var344 = 0.0725496113 + } + } else { + if (input[0]) >= (0.00390977459) { + var344 = 0.165156752 + } else { + var344 = -0.293561369 + } + } + } else { + if (input[4]) >= (0.133753508) { + if (input[0]) >= (0.0133834584) { + var344 = -0.180421501 + } else { + var344 = 0.362727284 + } + } else { + if (input[1]) >= (0.0073678866) { + var344 = -0.00125408464 + } else { + var344 = -0.0907725021 + } + } + } + var var345 float64 + if (input[4]) >= (0.052521009) { + if (input[4]) >= (0.0553221293) { + if (input[8]) >= (0.0215709414) { + var345 = -0.00999655854 + } else { + var345 = 0.0249625649 + } + } else { + if (input[5]) >= (0.00499999989) { + var345 = 0.0601425059 + } else { + var345 = -0.248763487 + } + } + } else { + if (input[8]) >= (0.0217020717) { + if (input[5]) >= (0.0649999976) { + var345 = -0.0648417026 + } else { + var345 = 0.0915710926 + } + } else { + if (input[5]) >= (0.00499999989) { + var345 = 0.0767970458 + } else { + var345 = -0.0240055062 + } + } + } + var var346 float64 + if (input[9]) >= (0.0452025533) { + if (input[3]) >= (0.0147749791) { + if (input[8]) >= (0.0685156062) { + var346 = 0.0169994589 + } else { + var346 = -0.121243596 + } + } else { + if (input[5]) >= (0.175000012) { + var346 = 0.318196774 + } else { + var346 = -0.00395076536 + } + } + } else { + if (input[5]) >= (0.685000002) { + if (input[8]) >= (0.0960529745) { + var346 = -0.235690475 + } else { + var346 = 0.0157146584 + } + } else { + if (input[9]) >= (0.0450581834) { + var346 = 0.198414057 + } else { + var346 = 0.00707878359 + } + } + } + var var347 float64 + if (input[1]) >= (0.0195630081) { + if (input[4]) >= (0.238795519) { + if (input[5]) >= (0.00499999989) { + var347 = -0.0458472632 + } else { + var347 = 0.0439547002 + } + } else { + if (input[4]) >= (0.199579835) { + var347 = -0.054550197 + } else { + var347 = 0.00307067554 + } + } + } else { + if (input[0]) >= (0.0236090235) { + if (input[8]) >= (0.0506818779) { + var347 = 0.00619618315 + } else { + var347 = -0.070866175 + } + } else { + if (input[5]) >= (0.00499999989) { + var347 = 0.169598728 + } else { + var347 = -0.0177909713 + } + } + } + var var348 float64 + if (input[0]) >= (0.00285714283) { + if (input[4]) >= (0.021708684) { + if (input[8]) >= (0.0113427751) { + var348 = -0.00385626429 + } else { + var348 = 0.0433700904 + } + } else { + if (input[8]) >= (0.0116050355) { + var348 = 0.00227908115 + } else { + var348 = -0.15142186 + } + } + } else { + if (input[4]) >= (0.0231092442) { + if (input[4]) >= (0.0259103645) { + var348 = 0.0996284708 + } else { + var348 = -0.333995104 + } + } else { + if (input[4]) >= (0.0161064435) { + var348 = 0.152937457 + } else { + var348 = -0.0633552298 + } + } + } + var var349 float64 + if (input[5]) >= (0.0549999997) { + if (input[0]) >= (0.00796992518) { + if (input[0]) >= (0.0347368419) { + var349 = 0.0102174552 + } else { + var349 = 0.137461096 + } + } else { + if (input[0]) >= (0.00195488706) { + var349 = -0.139117658 + } else { + var349 = 0.253046453 + } + } + } else { + if (input[0]) >= (0.122255638) { + if (input[1]) >= (0.0134654474) { + var349 = -0.0665988699 + } else { + var349 = 0.0672549158 + } + } else { + if (input[0]) >= (0.12045113) { + var349 = 0.0638346747 + } else { + var349 = -0.00340554724 + } + } + } + var var350 float64 + if (input[3]) >= (0.0234692991) { + if (input[3]) >= (0.0235923305) { + if (input[7]) >= (0.0171358436) { + var350 = -0.0138600487 + } else { + var350 = 0.0390772261 + } + } else { + if (input[5]) >= (0.00499999989) { + var350 = 0.404042274 + } else { + var350 = 0.075095728 + } + } + } else { + if (input[3]) >= (0.0231624823) { + if (input[0]) >= (0.0500751883) { + var350 = -0.0710452646 + } else { + var350 = -0.416528314 + } + } else { + if (input[3]) >= (0.0231525674) { + var350 = 0.343028963 + } else { + var350 = -0.00426955195 + } + } + } + var var351 float64 + if (input[2]) >= (0.475332975) { + var351 = -0.237791553 + } else { + if (input[3]) >= (0.111307517) { + if (input[5]) >= (0.0350000001) { + var351 = 0.127263561 + } else { + var351 = -0.0185106732 + } + } else { + if (input[4]) >= (0.35084033) { + var351 = -0.0221571289 + } else { + var351 = 0.000205447359 + } + } + } + var var352 float64 + if (input[1]) >= (0.0581808947) { + if (input[0]) >= (0.119548872) { + if (input[0]) >= (0.12105263) { + var352 = 0.0148318009 + } else { + var352 = 0.207496092 + } + } else { + if (input[0]) >= (0.0612030067) { + var352 = -0.0993124321 + } else { + var352 = -0.0159126185 + } + } + } else { + if (input[0]) >= (0.0121804513) { + if (input[8]) >= (0.0165879875) { + var352 = 0.000590711308 + } else { + var352 = -0.0870961845 + } + } else { + if (input[4]) >= (0.0357142873) { + var352 = 0.0842488781 + } else { + var352 = -0.000499365909 + } + } + } + var var353 float64 + if (input[7]) >= (0.362487584) { + var353 = 0.200774282 + } else { + if (input[2]) >= (0.333641768) { + var353 = -0.2732701 + } else { + if (input[6]) >= (0.0149471648) { + var353 = 0.00720896339 + } else { + var353 = -0.00538807362 + } + } + } + var var354 float64 + if (input[6]) >= (0.00130957039) { + if (input[9]) >= (0.361995786) { + if (input[2]) >= (0.00261302991) { + var354 = 0.0327775553 + } else { + var354 = 0.361897022 + } + } else { + if (input[9]) >= (0.285031617) { + var354 = -0.122448936 + } else { + var354 = 0.00175567006 + } + } + } else { + if (input[7]) >= (0.000147714018) { + if (input[4]) >= (0.0301120449) { + var354 = -0.0534958653 + } else { + var354 = -0.228099585 + } + } else { + var354 = 0.149858594 + } + } + var var355 float64 + if (input[0]) >= (0.0485714301) { + if (input[0]) >= (0.0509774461) { + if (input[0]) >= (0.0524812043) { + var355 = 0.00721961958 + } else { + var355 = -0.120354481 + } + } else { + if (input[4]) >= (0.262605071) { + var355 = -0.851768255 + } else { + var355 = 0.126444444 + } + } + } else { + if (input[4]) >= (0.327030838) { + if (input[8]) >= (0.0245869402) { + var355 = 0.290691018 + } else { + var355 = 0.00268158969 + } + } else { + if (input[8]) >= (0.0416338854) { + var355 = 0.079033874 + } else { + var355 = -0.0149792815 + } + } + } + var var356 float64 + if (input[4]) >= (0.00350140082) { + if (input[1]) >= (0.010416666) { + if (input[4]) >= (0.0063025211) { + var356 = 0.00260222889 + } else { + var356 = -0.159914255 + } + } else { + if (input[4]) >= (0.437675059) { + var356 = 0.13099274 + } else { + var356 = -0.0401971824 + } + } + } else { + if (input[8]) >= (0.0554681346) { + var356 = 0.234395728 + } else { + var356 = 0.0209439378 + } + } + var var357 float64 + if (input[7]) >= (0.109669231) { + if (input[8]) >= (0.0335038044) { + if (input[7]) >= (0.111621827) { + var357 = 0.0142685613 + } else { + var357 = 0.297769785 + } + } else { + var357 = 0.62544775 + } + } else { + if (input[7]) >= (0.103159457) { + if (input[1]) >= (0.023119919) { + var357 = -0.260620058 + } else { + var357 = 0.0687360987 + } + } else { + if (input[7]) >= (0.102549091) { + var357 = 0.297759026 + } else { + var357 = 0.00145329605 + } + } + } + var var358 float64 + if (input[5]) >= (0.145000011) { + if (input[4]) >= (0.55252099) { + var358 = -0.357375175 + } else { + if (input[0]) >= (0.172781944) { + var358 = -0.107276797 + } else { + var358 = -0.00897039101 + } + } + } else { + if (input[4]) >= (0.0077030817) { + if (input[5]) >= (0.125) { + var358 = 0.0851260498 + } else { + var358 = -0.000605561654 + } + } else { + if (input[0]) >= (0.00631578919) { + var358 = 0.333426714 + } else { + var358 = 0.100194514 + } + } + } + var var359 float64 + if (input[8]) >= (0.0439942293) { + if (input[0]) >= (0.0858646631) { + if (input[4]) >= (0.109943978) { + var359 = -0.0227243043 + } else { + var359 = 0.0477193482 + } + } else { + if (input[6]) >= (0.11902038) { + var359 = -0.373027742 + } else { + var359 = 0.0625631288 + } + } + } else { + if (input[0]) >= (0.194586471) { + if (input[0]) >= (0.224812031) { + var359 = -0.137703136 + } else { + var359 = 0.341481239 + } + } else { + if (input[8]) >= (0.0394046679) { + var359 = -0.0634013265 + } else { + var359 = -0.000297934923 + } + } + } + var var360 float64 + if (input[4]) >= (0.395658255) { + if (input[8]) >= (0.0790060312) { + if (input[0]) >= (0.160751879) { + var360 = 0.171707958 + } else { + var360 = -0.0467407443 + } + } else { + if (input[7]) >= (0.000359430705) { + var360 = 0.0536948368 + } else { + var360 = 0.308334112 + } + } + } else { + if (input[8]) >= (0.0835955963) { + if (input[4]) >= (0.0721288547) { + var360 = 0.0625491142 + } else { + var360 = -0.113844141 + } + } else { + if (input[4]) >= (0.370448172) { + var360 = -0.0905230194 + } else { + var360 = -0.000279840227 + } + } + } + var var361 float64 + if (input[9]) >= (0.0281379037) { + if (input[4]) >= (0.558123231) { + if (input[4]) >= (0.586134434) { + var361 = -0.124454103 + } else { + var361 = 0.347777128 + } + } else { + if (input[0]) >= (0.121954888) { + var361 = -0.0784919262 + } else { + var361 = -0.0059832586 + } + } + } else { + if (input[7]) >= (0.0114560667) { + if (input[0]) >= (0.041052632) { + var361 = 0.00390737737 + } else { + var361 = 0.167634696 + } + } else { + if (input[7]) >= (0.000389095396) { + var361 = -0.025253566 + } else { + var361 = 0.0233056955 + } + } + } + var var362 float64 + if (input[4]) >= (0.182773113) { + if (input[4]) >= (0.184173673) { + if (input[8]) >= (0.0335038044) { + var362 = -0.00454044435 + } else { + var362 = 0.0544599257 + } + } else { + if (input[1]) >= (0.0335365832) { + var362 = 0.439274102 + } else { + var362 = -0.212054521 + } + } + } else { + if (input[4]) >= (0.174369752) { + if (input[5]) >= (0.00499999989) { + var362 = 0.0957624242 + } else { + var362 = -0.161029801 + } + } else { + if (input[4]) >= (0.164565831) { + var362 = 0.0810947418 + } else { + var362 = -0.000839515298 + } + } + } + var var363 float64 + if (input[8]) >= (0.0113427751) { + if (input[8]) >= (0.0114739053) { + if (input[9]) >= (0.143461436) { + var363 = -0.0401195213 + } else { + var363 = 0.000398501201 + } + } else { + if (input[1]) >= (0.0434451215) { + var363 = 0.0838890597 + } else { + var363 = -0.331377804 + } + } + } else { + if (input[6]) >= (0.00338681997) { + if (input[8]) >= (0.00898242835) { + var363 = -0.0203330554 + } else { + var363 = 0.0973686799 + } + } else { + if (input[6]) >= (0.00218261732) { + var363 = 0.141876206 + } else { + var363 = -0.0487607867 + } + } + } + var var364 float64 + if (input[0]) >= (0.00766917318) { + if (input[4]) >= (0.0203081239) { + if (input[8]) >= (0.0116050355) { + var364 = 0.00118055823 + } else { + var364 = -0.18069385 + } + } else { + if (input[8]) >= (0.0289142411) { + var364 = -0.0235658083 + } else { + var364 = -0.186606646 + } + } + } else { + if (input[4]) >= (0.0203081239) { + if (input[0]) >= (0.00706766918) { + var364 = 0.0773718506 + } else { + var364 = -0.0175629538 + } + } else { + if (input[8]) >= (0.0133097302) { + var364 = 0.141518921 + } else { + var364 = 0.0109437685 + } + } + } + var var365 float64 + if (input[8]) >= (0.0113427751) { + if (input[8]) >= (0.0116050355) { + if (input[8]) >= (0.011867296) { + var365 = -0.00343311741 + } else { + var365 = 0.0795543417 + } + } else { + if (input[4]) >= (0.0189075638) { + var365 = -0.205264255 + } else { + var365 = 0.126471967 + } + } + } else { + if (input[4]) >= (0.0315126069) { + if (input[1]) >= (0.0403963402) { + var365 = 0.0432360433 + } else { + var365 = -0.270766705 + } + } else { + if (input[8]) >= (0.0112116449) { + var365 = 0.21591951 + } else { + var365 = 0.0327033773 + } + } + } + var var366 float64 + if (input[8]) >= (0.0922501981) { + if (input[4]) >= (0.0959383771) { + if (input[0]) >= (0.0690225586) { + var366 = 0.0471365266 + } else { + var366 = -0.248978615 + } + } else { + if (input[0]) >= (0.128571421) { + var366 = -0.209224775 + } else { + var366 = 0.0531880446 + } + } + } else { + if (input[0]) >= (0.0169924796) { + if (input[4]) >= (0.0287114847) { + var366 = -0.014346444 + } else { + var366 = 0.0964797214 + } + } else { + if (input[7]) >= (0.0377461165) { + var366 = -0.22629492 + } else { + var366 = 0.0124570262 + } + } + } + var var367 float64 + if (input[7]) >= (0.000219640817) { + if (input[7]) >= (0.000228174496) { + if (input[2]) >= (0.289008677) { + var367 = -0.115063578 + } else { + var367 = 0.000659263169 + } + } else { + if (input[2]) >= (0.0045257546) { + var367 = 0.222791821 + } else { + var367 = -0.0687061697 + } + } + } else { + if (input[6]) >= (0.00335671497) { + if (input[2]) >= (0.0713600218) { + var367 = -0.264460325 + } else { + var367 = -0.041916348 + } + } else { + if (input[6]) >= (0.00311587448) { + var367 = 0.25740397 + } else { + var367 = 0.00450923759 + } + } + } + var var368 float64 + if (input[8]) >= (0.00976921059) { + if (input[8]) >= (0.0113427751) { + if (input[4]) >= (0.0273109246) { + var368 = 0.00241965381 + } else { + var368 = -0.035104651 + } + } else { + if (input[4]) >= (0.0133053223) { + var368 = 0.0126722408 + } else { + var368 = 0.343450665 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[3]) >= (0.00403818255) { + var368 = -0.102595046 + } else { + var368 = -0.31252715 + } + } else { + if (input[7]) >= (0.00108885765) { + var368 = 0.045343291 + } else { + var368 = -0.0733816475 + } + } + } + var var369 float64 + if (input[4]) >= (0.378851533) { + if (input[5]) >= (0.114999995) { + if (input[1]) >= (0.0818089396) { + var369 = 0.0891378298 + } else { + var369 = -0.1466133 + } + } else { + if (input[6]) >= (0.0915495083) { + var369 = 0.459486097 + } else { + var369 = 0.0385961719 + } + } + } else { + if (input[4]) >= (0.370448172) { + if (input[2]) >= (0.059919104) { + var369 = 0.157053441 + } else { + var369 = -0.167116597 + } + } else { + if (input[2]) >= (0.0837274641) { + var369 = -0.0301948767 + } else { + var369 = 0.00116103783 + } + } + } + var var370 float64 + if (input[8]) >= (0.261605024) { + if (input[7]) >= (0.0182700101) { + if (input[3]) >= (0.0845829695) { + var370 = -0.0887198672 + } else { + var370 = 0.228913859 + } + } else { + var370 = 0.316832513 + } + } else { + if (input[9]) >= (0.0282533988) { + if (input[0]) >= (0.0206015036) { + var370 = -0.0176599976 + } else { + var370 = 0.00713887485 + } + } else { + if (input[7]) >= (0.0323702991) { + var370 = 0.036912404 + } else { + var370 = 0.00276314584 + } + } + } + var var371 float64 + if (input[2]) >= (0.000943549559) { + if (input[2]) >= (0.00108008704) { + if (input[6]) >= (0.00534364954) { + var371 = 0.00450270716 + } else { + var371 = -0.0105378684 + } + } else { + if (input[9]) >= (0.0733115822) { + var371 = 0.241019174 + } else { + var371 = -0.0950988159 + } + } + } else { + if (input[4]) >= (0.0259103645) { + if (input[1]) >= (0.03125) { + var371 = 0.167915657 + } else { + var371 = -0.112989381 + } + } else { + if (input[0]) >= (0.00496240612) { + var371 = 0.0935288444 + } else { + var371 = -0.189650357 + } + } + } + var var372 float64 + if (input[7]) >= (0.0602864251) { + if (input[3]) >= (0.0029153917) { + if (input[5]) >= (0.0249999985) { + var372 = 0.0596894659 + } else { + var372 = -0.00495819049 + } + } else { + if (input[6]) >= (0.00973898917) { + var372 = 0.14815563 + } else { + var372 = 0.350634903 + } + } + } else { + if (input[7]) >= (0.0593838841) { + if (input[5]) >= (0.0450000018) { + var372 = 0.0358560309 + } else { + var372 = -0.394914657 + } + } else { + if (input[7]) >= (0.0581948571) { + var372 = 0.159882337 + } else { + var372 = -0.00114652212 + } + } + } + var var373 float64 + if (input[2]) >= (0.00204565888) { + if (input[2]) >= (0.00220401818) { + if (input[0]) >= (0.195037603) { + var373 = -0.0449707657 + } else { + var373 = -0.00204380741 + } + } else { + if (input[8]) >= (0.0175059009) { + var373 = 0.00671124132 + } else { + var373 = -0.227475435 + } + } + } else { + if (input[7]) >= (0.000696104893) { + if (input[3]) >= (0.00257527549) { + var373 = 0.241141379 + } else { + var373 = 0.0034582282 + } + } else { + if (input[3]) >= (0.00345403655) { + var373 = 0.125218794 + } else { + var373 = -0.0299157668 + } + } + } + var var374 float64 + if (input[3]) >= (0.00183251023) { + if (input[9]) >= (0.158216149) { + if (input[6]) >= (0.0312942155) { + var374 = -0.186792642 + } else { + var374 = -0.00780218095 + } + } else { + if (input[9]) >= (0.153076544) { + var374 = 0.152375877 + } else { + var374 = 0.000777820242 + } + } + } else { + if (input[0]) >= (0.00676691718) { + var374 = 0.0232269727 + } else { + var374 = 0.246220991 + } + } + var var375 float64 + if (input[0]) >= (0.00526315812) { + if (input[8]) >= (0.0119984262) { + if (input[8]) >= (0.0133097302) { + var375 = 0.000507705496 + } else { + var375 = -0.137016475 + } + } else { + if (input[0]) >= (0.00616541365) { + var375 = -0.00705092587 + } else { + var375 = 0.245335996 + } + } + } else { + if (input[8]) >= (0.0119984262) { + if (input[7]) >= (0.0121257566) { + var375 = -0.241480067 + } else { + var375 = 0.0538871475 + } + } else { + if (input[0]) >= (0.00436090212) { + var375 = -0.164288908 + } else { + var375 = -0.0254081208 + } + } + } + var var376 float64 + if (input[6]) >= (0.00278471876) { + if (input[6]) >= (0.00284492876) { + if (input[7]) >= (0.0202087834) { + var376 = -0.0139367515 + } else { + var376 = 0.00337252207 + } + } else { + if (input[8]) >= (0.0117361657) { + var376 = -0.161143795 + } else { + var376 = 0.122937188 + } + } + } else { + if (input[8]) >= (0.00885129813) { + if (input[8]) >= (0.0622213483) { + var376 = -0.0307949707 + } else { + var376 = 0.0314185359 + } + } else { + if (input[0]) >= (0.00375939859) { + var376 = -0.0196830072 + } else { + var376 = -0.225987479 + } + } + } + var var377 float64 + if (input[8]) >= (0.190597951) { + if (input[7]) >= (0.128878772) { + if (input[8]) >= (0.252098083) { + var377 = -0.040143013 + } else { + var377 = 0.179379702 + } + } else { + if (input[3]) >= (0.0231759548) { + var377 = -0.16989781 + } else { + var377 = 0.0472523943 + } + } + } else { + if (input[8]) >= (0.163453966) { + if (input[1]) >= (0.0711382106) { + var377 = -0.105880164 + } else { + var377 = 0.175420105 + } + } else { + if (input[5]) >= (0.0149999997) { + var377 = -0.0112480614 + } else { + var377 = 0.00508819055 + } + } + } + var var378 float64 + if (input[8]) >= (0.0416338854) { + if (input[8]) >= (0.0421584062) { + if (input[9]) >= (0.0530563369) { + var378 = 0.0694859475 + } else { + var378 = 0.00595745677 + } + } else { + if (input[2]) >= (0.0113840569) { + var378 = 0.217752889 + } else { + var378 = -0.131873772 + } + } + } else { + if (input[4]) >= (0.223389357) { + if (input[5]) >= (0.00499999989) { + var378 = -0.219911322 + } else { + var378 = 0.0686080605 + } + } else { + if (input[4]) >= (0.212184876) { + var378 = -0.116209276 + } else { + var378 = -0.00899004284 + } + } + } + var var379 float64 + if (input[4]) >= (0.343837559) { + if (input[0]) >= (0.0572932325) { + if (input[0]) >= (0.119097739) { + var379 = 3.795066e-05 + } else { + var379 = -0.142422289 + } + } else { + if (input[8]) >= (0.0240624174) { + var379 = 0.171135634 + } else { + var379 = -0.0260310993 + } + } + } else { + if (input[0]) >= (0.0584962405) { + if (input[4]) >= (0.0581232496) { + var379 = 0.0336130746 + } else { + var379 = -0.0640132129 + } + } else { + if (input[0]) >= (0.0554887205) { + var379 = -0.0967705548 + } else { + var379 = -0.00222649192 + } + } + } + var var380 float64 + if (input[4]) >= (0.0693277344) { + if (input[0]) >= (0.00195488706) { + if (input[0]) >= (0.0127819553) { + var380 = -0.0117792049 + } else { + var380 = 0.0715114623 + } + } else { + if (input[5]) >= (0.0149999997) { + var380 = -0.55547899 + } else { + var380 = 0.251182109 + } + } + } else { + if (input[8]) >= (0.018817205) { + if (input[0]) >= (0.00676691718) { + var380 = 0.0462006852 + } else { + var380 = -0.140044883 + } + } else { + if (input[0]) >= (0.0190977454) { + var380 = -0.188134044 + } else { + var380 = 0.00305217854 + } + } + } + var var381 float64 + if (input[1]) >= (0.0078760162) { + if (input[7]) >= (0.00750862714) { + if (input[7]) >= (0.00776788872) { + var381 = 0.0106730275 + } else { + var381 = 0.143622488 + } + } else { + if (input[7]) >= (0.00633118208) { + var381 = -0.0583225414 + } else { + var381 = 0.00171308103 + } + } + } else { + if (input[0]) >= (0.0981954932) { + if (input[0]) >= (0.13909775) { + var381 = -0.0512938909 + } else { + var381 = -0.258512884 + } + } else { + if (input[6]) >= (0.0428696126) { + var381 = -0.224829867 + } else { + var381 = 0.155539855 + } + } + } + var var382 float64 + if (input[3]) >= (0.0657375231) { + if (input[3]) >= (0.0664856285) { + if (input[1]) >= (0.0947662592) { + var382 = 0.0527851619 + } else { + var382 = -0.042252399 + } + } else { + if (input[6]) >= (0.0209079683) { + var382 = 0.343732774 + } else { + var382 = 0.0853003189 + } + } + } else { + if (input[3]) >= (0.0620315783) { + if (input[8]) >= (0.0525177009) { + var382 = -0.288604587 + } else { + var382 = 0.152235508 + } + } else { + if (input[3]) >= (0.0549747981) { + var382 = 0.107932642 + } else { + var382 = -0.00181106979 + } + } + } + var var383 float64 + if (input[3]) >= (0.00207933597) { + if (input[6]) >= (0.000737574184) { + if (input[4]) >= (0.0203081239) { + var383 = -0.00446364703 + } else { + var383 = 0.016253788 + } + } else { + if (input[6]) >= (0.000587048824) { + var383 = 0.237651348 + } else { + var383 = -0.00987365004 + } + } + } else { + if (input[6]) >= (0.0564771071) { + if (input[9]) >= (0.0316749923) { + var383 = -0.135149971 + } else { + var383 = 0.136942387 + } + } else { + if (input[1]) >= (0.0185467489) { + var383 = 0.0582024045 + } else { + var383 = 0.241506249 + } + } + } + var var384 float64 + if (input[9]) >= (0.0169635899) { + if (input[9]) >= (0.0171079598) { + if (input[1]) >= (0.00533536542) { + var384 = 0.00251786015 + } else { + var384 = 0.136503458 + } + } else { + if (input[3]) >= (0.0169173554) { + var384 = -0.0530295707 + } else { + var384 = 0.390390366 + } + } + } else { + if (input[6]) >= (0.00338681997) { + if (input[6]) >= (0.0655838847) { + var384 = -0.125228494 + } else { + var384 = -0.0153479651 + } + } else { + if (input[9]) >= (0.000534172636) { + var384 = 0.0272525754 + } else { + var384 = 0.418567508 + } + } + } + var var385 float64 + if (input[3]) >= (0.00321381981) { + if (input[3]) >= (0.00322500453) { + if (input[2]) >= (0.00147168105) { + var385 = 0.00105496007 + } else { + var385 = 0.173852414 + } + } else { + var385 = -0.280907452 + } + } else { + if (input[2]) >= (0.0100367013) { + if (input[9]) >= (0.0719978064) { + var385 = -0.0353418142 + } else { + var385 = 0.0989455581 + } + } else { + if (input[9]) >= (0.0785233751) { + var385 = 0.0399525948 + } else { + var385 = -0.0425276048 + } + } + } + var var386 float64 + if (input[8]) >= (0.0135719907) { + if (input[2]) >= (0.00553416926) { + if (input[9]) >= (0.149438396) { + var386 = 0.0530991368 + } else { + var386 = -0.000525882002 + } + } else { + if (input[0]) >= (0.0281203017) { + var386 = -0.0309329368 + } else { + var386 = 0.0606322587 + } + } + } else { + if (input[0]) >= (0.0172932334) { + if (input[9]) >= (0.0954292119) { + var386 = -0.203959614 + } else { + var386 = 0.286654383 + } + } else { + if (input[0]) >= (0.00616541365) { + var386 = -0.0914710164 + } else { + var386 = -0.00254739542 + } + } + } + var var387 float64 + if (input[7]) >= (2.98678988e-05) { + if (input[9]) >= (0.0239222702) { + if (input[7]) >= (0.0258749463) { + var387 = -0.0368935838 + } else { + var387 = -0.00198683422 + } + } else { + if (input[8]) >= (0.00976921059) { + var387 = 0.00790642574 + } else { + var387 = -0.174867645 + } + } + } else { + if (input[8]) >= (0.0243246779) { + var387 = -0.214325771 + } else { + if (input[9]) >= (0.0376519486) { + var387 = 0.041372817 + } else { + var387 = 0.273587435 + } + } + } + var var388 float64 + if (input[7]) >= (0.293373287) { + if (input[9]) >= (0.0153466351) { + var388 = 0.00602999236 + } else { + if (input[8]) >= (0.125819564) { + var388 = -0.315832376 + } else { + var388 = -0.0371238329 + } + } + } else { + if (input[3]) >= (0.00246495381) { + if (input[8]) >= (0.03311041) { + var388 = 0.00275210198 + } else { + var388 = -0.0119292159 + } + } else { + if (input[9]) >= (0.0643028319) { + var388 = -0.0200583674 + } else { + var388 = 0.138075292 + } + } + } + var var389 float64 + if (input[1]) >= (0.108485773) { + if (input[5]) >= (0.0149999997) { + if (input[5]) >= (0.0949999988) { + var389 = 0.000182629999 + } else { + var389 = -0.169213936 + } + } else { + if (input[7]) >= (0.0476691648) { + var389 = 0.214481756 + } else { + var389 = -0.0195852835 + } + } + } else { + if (input[1]) >= (0.0673272386) { + if (input[1]) >= (0.0713922754) { + var389 = 0.0142043158 + } else { + var389 = 0.110468626 + } + } else { + if (input[1]) >= (0.0627540648) { + var389 = -0.0726757273 + } else { + var389 = -0.000587915303 + } + } + } + var var390 float64 + if (input[1]) >= (0.0525914654) { + if (input[3]) >= (0.0107492525) { + if (input[1]) >= (0.061229676) { + var390 = 0.00954389479 + } else { + var390 = -0.0666927621 + } + } else { + if (input[1]) >= (0.061229676) { + var390 = 0.011410322 + } else { + var390 = 0.141680419 + } + } + } else { + if (input[1]) >= (0.0505589433) { + if (input[5]) >= (0.00499999989) { + var390 = 0.0583063141 + } else { + var390 = -0.131954119 + } + } else { + if (input[6]) >= (0.120450377) { + var390 = 0.116027258 + } else { + var390 = -0.00344907562 + } + } + } + var var391 float64 + if (input[9]) >= (0.0266075712) { + if (input[7]) >= (0.173347592) { + if (input[4]) >= (0.112745099) { + var391 = 0.0683095157 + } else { + var391 = 0.32496655 + } + } else { + if (input[9]) >= (0.0266941935) { + var391 = 0.00470174151 + } else { + var391 = 0.187384352 + } + } + } else { + if (input[7]) >= (0.000124957529) { + if (input[8]) >= (0.00911355857) { + var391 = -0.0097337449 + } else { + var391 = -0.235695422 + } + } else { + if (input[7]) >= (0.000105451967) { + var391 = 0.194194183 + } else { + var391 = 0.00837586261 + } + } + } + var var392 float64 + if (input[1]) >= (0.0205792673) { + if (input[4]) >= (0.233193278) { + if (input[2]) >= (0.00714879483) { + var392 = 0.0319337472 + } else { + var392 = -0.135953531 + } + } else { + if (input[4]) >= (0.199579835) { + var392 = -0.0522379056 + } else { + var392 = 0.00771449739 + } + } + } else { + if (input[7]) >= (0.00474879285) { + if (input[9]) >= (0.00417232141) { + var392 = -0.0286123566 + } else { + var392 = 0.133791775 + } + } else { + if (input[7]) >= (0.00452447869) { + var392 = 0.318739235 + } else { + var392 = 0.0167138707 + } + } + } + var var393 float64 + if (input[3]) >= (0.0119765177) { + if (input[3]) >= (0.0120512526) { + if (input[7]) >= (4.49034414e-05) { + var393 = -0.00361608132 + } else { + var393 = -0.240335554 + } + } else { + if (input[1]) >= (0.0490345508) { + var393 = 0.106574021 + } else { + var393 = -0.310080439 + } + } + } else { + if (input[3]) >= (0.0117790066) { + if (input[0]) >= (0.0478195474) { + var393 = 0.196387634 + } else { + var393 = -0.109476805 + } + } else { + if (input[5]) >= (0.00499999989) { + var393 = 0.0333147757 + } else { + var393 = -0.00325993425 + } + } + } + var var394 float64 + if (input[8]) >= (0.0522554405) { + if (input[2]) >= (0.018089205) { + if (input[0]) >= (0.0858646631) { + var394 = -0.0132809207 + } else { + var394 = 0.0535592474 + } + } else { + if (input[1]) >= (0.0429369919) { + var394 = -0.292654604 + } else { + var394 = -0.0370716043 + } + } + } else { + if (input[8]) >= (0.0436008386) { + if (input[7]) >= (0.00600486994) { + var394 = 0.0226851497 + } else { + var394 = 0.134628743 + } + } else { + if (input[8]) >= (0.0434697084) { + var394 = -0.304034293 + } else { + var394 = 0.00283504114 + } + } + } + var var395 float64 + if (input[4]) >= (0.126750708) { + if (input[5]) >= (0.524999976) { + if (input[7]) >= (0.0513835549) { + var395 = -0.327600986 + } else { + var395 = 0.000642183237 + } + } else { + if (input[0]) >= (0.250075191) { + var395 = -0.259777993 + } else { + var395 = 0.0101173911 + } + } + } else { + if (input[2]) >= (0.252100915) { + if (input[1]) >= (0.0660569072) { + var395 = -0.13608624 + } else { + var395 = -0.422872812 + } + } else { + if (input[9]) >= (0.0365691707) { + var395 = -0.0219368767 + } else { + var395 = 0.0143457698 + } + } + } + var var396 float64 + if (input[0]) >= (0.00345864659) { + if (input[0]) >= (0.00646616518) { + if (input[4]) >= (0.0175070036) { + var396 = 0.00122059672 + } else { + var396 = -0.0693136603 + } + } else { + if (input[8]) >= (0.0378311053) { + var396 = -0.366828501 + } else { + var396 = -0.0152960354 + } + } + } else { + if (input[4]) >= (0.0259103645) { + if (input[4]) >= (0.0882352963) { + var396 = -0.0518234223 + } else { + var396 = 0.32437861 + } + } else { + if (input[4]) >= (0.0231092442) { + var396 = -0.198393688 + } else { + var396 = 0.0563943237 + } + } + } + var var397 float64 + if (input[7]) >= (0.129189223) { + if (input[8]) >= (0.0392079726) { + if (input[8]) >= (0.0569761358) { + var397 = 0.0584353954 + } else { + var397 = -0.113235123 + } + } else { + if (input[7]) >= (0.162795082) { + var397 = 0.0402061716 + } else { + var397 = 0.408717424 + } + } + } else { + if (input[2]) >= (0.167903185) { + if (input[4]) >= (0.30392158) { + var397 = 0.0676442683 + } else { + var397 = -0.290525764 + } + } else { + if (input[2]) >= (0.139028907) { + var397 = 0.092793107 + } else { + var397 = -0.00295657828 + } + } + } + var var398 float64 + if (input[3]) >= (0.00321229454) { + if (input[6]) >= (0.17236656) { + if (input[4]) >= (0.230392158) { + var398 = 0.0579715036 + } else { + var398 = -0.377036393 + } + } else { + if (input[3]) >= (0.00322500453) { + var398 = -0.00461096736 + } else { + var398 = -0.197151721 + } + } + } else { + if (input[5]) >= (0.0149999997) { + if (input[4]) >= (0.0315126069) { + var398 = -0.101015195 + } else { + var398 = 0.0594433062 + } + } else { + if (input[4]) >= (0.0245098043) { + var398 = 0.0526369102 + } else { + var398 = -0.0399624929 + } + } + } + var var399 float64 + if (input[0]) >= (0.273834586) { + if (input[6]) >= (0.0181081966) { + var399 = -0.0779463649 + } else { + if (input[6]) >= (0.00356745045) { + var399 = 0.12178003 + } else { + var399 = 0.299270689 + } + } + } else { + if (input[6]) >= (0.00197188184) { + if (input[8]) >= (0.0123918178) { + var399 = -5.07961022e-06 + } else { + var399 = 0.0202378258 + } + } else { + if (input[0]) >= (0.220751882) { + var399 = 0.340895325 + } else { + var399 = -0.0208084285 + } + } + } + var var400 float64 + if (input[2]) >= (0.273227781) { + if (input[8]) >= (0.0691712573) { + if (input[7]) >= (0.227387369) { + var400 = -0.0333318524 + } else { + var400 = 0.179649979 + } + } else { + var400 = 0.328843534 + } + } else { + if (input[7]) >= (1.84896508e-05) { + if (input[2]) >= (0.00104244915) { + var400 = -0.00212030648 + } else { + var400 = -0.0561211258 + } + } else { + if (input[7]) >= (1.60514555e-05) { + var400 = 0.251688004 + } else { + var400 = -0.0353204682 + } + } + } + var var401 float64 + if (input[3]) >= (0.20521751) { + if (input[5]) >= (0.210000008) { + var401 = 0.279753149 + } else { + var401 = 0.0599051528 + } + } else { + if (input[3]) >= (0.0275758598) { + if (input[0]) >= (0.0260150358) { + var401 = -0.0136689916 + } else { + var401 = -0.186359107 + } + } else { + if (input[3]) >= (0.0272733644) { + var401 = 0.16065231 + } else { + var401 = 0.00487277983 + } + } + } + var var402 float64 + if (input[9]) >= (0.144356534) { + if (input[8]) >= (0.0348151065) { + if (input[2]) >= (0.0202744044) { + var402 = -0.323902905 + } else { + var402 = -0.0167714581 + } + } else { + if (input[4]) >= (0.171568632) { + var402 = 0.133033857 + } else { + var402 = -0.0258398447 + } + } + } else { + if (input[9]) >= (0.141440243) { + if (input[1]) >= (0.0459857732) { + var402 = 0.384210557 + } else { + var402 = 0.152407646 + } + } else { + if (input[3]) >= (0.00370594626) { + var402 = 0.00592891313 + } else { + var402 = -0.011945297 + } + } + } + var var403 float64 + if (input[2]) >= (0.0943437442) { + if (input[4]) >= (0.191176474) { + if (input[4]) >= (0.317226887) { + var403 = 0.0119016413 + } else { + var403 = -0.180498123 + } + } else { + if (input[9]) >= (0.00961510651) { + var403 = 0.0610132441 + } else { + var403 = -0.0906068832 + } + } + } else { + if (input[2]) >= (0.0928392336) { + if (input[5]) >= (0.0149999997) { + var403 = 0.396662116 + } else { + var403 = -0.0201099273 + } + } else { + if (input[4]) >= (0.574929953) { + var403 = -0.0904034004 + } else { + var403 = 0.000878079853 + } + } + } + var var404 float64 + if (input[4]) >= (0.0693277344) { + if (input[4]) >= (0.0805322155) { + if (input[0]) >= (0.154736847) { + var404 = -0.0592742749 + } else { + var404 = 0.000843432907 + } + } else { + if (input[5]) >= (0.00999999978) { + var404 = 0.124525718 + } else { + var404 = -0.212948546 + } + } + } else { + if (input[0]) >= (0.0681203008) { + if (input[0]) >= (0.0822556391) { + var404 = -0.023126781 + } else { + var404 = -0.295816243 + } + } else { + if (input[4]) >= (0.0679271743) { + var404 = 0.460309714 + } else { + var404 = 0.0142134875 + } + } + } + var var405 float64 + if (input[2]) >= (0.167666137) { + if (input[1]) >= (0.0160060972) { + if (input[2]) >= (0.170700192) { + var405 = -0.0608127303 + } else { + var405 = -0.285786301 + } + } else { + if (input[4]) >= (0.0497198887) { + var405 = 0.156904176 + } else { + var405 = -0.16906032 + } + } + } else { + if (input[7]) >= (0.159184724) { + var405 = 0.280112118 + } else { + if (input[7]) >= (0.142895952) { + var405 = -0.120487802 + } else { + var405 = 0.00206477987 + } + } + } + var var406 float64 + if (input[3]) >= (0.0656716824) { + if (input[4]) >= (0.157563031) { + if (input[5]) >= (0.405000001) { + var406 = -0.161617219 + } else { + var406 = 0.0967502594 + } + } else { + if (input[5]) >= (0.465000004) { + var406 = 0.245796934 + } else { + var406 = -0.119531386 + } + } + } else { + if (input[5]) >= (0.234999999) { + if (input[4]) >= (0.101540618) { + var406 = 0.126362473 + } else { + var406 = -0.0376993157 + } + } else { + if (input[9]) >= (0.00483642798) { + var406 = -0.0010997951 + } else { + var406 = -0.0412035249 + } + } + } + var var407 float64 + if (input[3]) >= (0.016347954) { + if (input[3]) >= (0.0167877153) { + if (input[7]) >= (0.000686758489) { + var407 = 0.00401364034 + } else { + var407 = 0.0466557033 + } + } else { + if (input[0]) >= (0.13203007) { + var407 = 0.619295776 + } else { + var407 = 0.0936494991 + } + } + } else { + if (input[3]) >= (0.014527645) { + if (input[3]) >= (0.0146016162) { + var407 = -0.0447811969 + } else { + var407 = -0.350080818 + } + } else { + if (input[0]) >= (0.136390984) { + var407 = 0.0332939923 + } else { + var407 = -0.00566680543 + } + } + } + var var408 float64 + if (input[6]) >= (0.0175964125) { + if (input[1]) >= (0.0302337408) { + if (input[9]) >= (0.0237490255) { + var408 = 0.0551197268 + } else { + var408 = -0.007971121 + } + } else { + if (input[3]) >= (0.0242090151) { + var408 = 0.153075933 + } else { + var408 = -0.0248793308 + } + } + } else { + if (input[1]) >= (0.014989838) { + if (input[3]) >= (0.0457431078) { + var408 = -0.0553948395 + } else { + var408 = -0.00777787995 + } + } else { + if (input[9]) >= (0.0315450579) { + var408 = -0.0499479771 + } else { + var408 = 0.0595041253 + } + } + } + var var409 float64 + if (input[7]) >= (0.00790544413) { + if (input[2]) >= (0.0111818537) { + if (input[7]) >= (0.00814540312) { + var409 = 0.00168789551 + } else { + var409 = 0.164706916 + } + } else { + if (input[2]) >= (0.0101025673) { + var409 = 0.236226112 + } else { + var409 = 0.0075898678 + } + } + } else { + if (input[8]) >= (0.0685156062) { + if (input[9]) >= (0.0180896837) { + var409 = 0.121917062 + } else { + var409 = -0.0101374174 + } + } else { + if (input[8]) >= (0.0623524785) { + var409 = -0.12535505 + } else { + var409 = -0.0115151964 + } + } + } + var var410 float64 + if (input[9]) >= (0.00402795058) { + if (input[9]) >= (0.00446106307) { + if (input[9]) >= (0.00512516964) { + var410 = -0.00194008346 + } else { + var410 = 0.0816422999 + } + } else { + if (input[8]) >= (0.171256229) { + var410 = 0.201432705 + } else { + var410 = -0.164862335 + } + } + } else { + if (input[0]) >= (0.206466168) { + if (input[7]) >= (0.00165106496) { + var410 = -0.267043561 + } else { + var410 = 0.0122480756 + } + } else { + if (input[8]) >= (0.0169813801) { + var410 = 0.0439045727 + } else { + var410 = -0.112719052 + } + } + } + var var411 float64 + if (input[8]) >= (0.191909254) { + if (input[2]) >= (0.148467213) { + if (input[1]) >= (0.113821141) { + var411 = -0.140394449 + } else { + var411 = 0.102789991 + } + } else { + if (input[0]) >= (0.180300742) { + var411 = 0.0214459449 + } else { + var411 = -0.181980222 + } + } + } else { + if (input[5]) >= (0.275000006) { + if (input[8]) >= (0.0742853433) { + var411 = 0.101861015 + } else { + var411 = -0.0420491248 + } + } else { + if (input[5]) >= (0.145000011) { + var411 = -0.0368860662 + } else { + var411 = 0.00124553265 + } + } + } + var var412 float64 + if (input[0]) >= (0.00135338353) { + if (input[0]) >= (0.00526315812) { + if (input[8]) >= (0.0119984262) { + var412 = -0.00250296853 + } else { + var412 = 0.0464082472 + } + } else { + if (input[6]) >= (0.00278471876) { + var412 = -0.0464743823 + } else { + var412 = 0.0484088585 + } + } + } else { + if (input[8]) >= (0.00832677633) { + if (input[8]) >= (0.00911355857) { + var412 = 0.136754066 + } else { + var412 = -0.205474183 + } + } else { + if (input[0]) >= (0.000751879707) { + var412 = 0.274985403 + } else { + var412 = 0.0509285852 + } + } + } + var var413 float64 + if (input[6]) >= (0.002935244) { + if (input[7]) >= (0.00127355102) { + if (input[7]) >= (0.00129122788) { + var413 = 0.00193174963 + } else { + var413 = 0.192074195 + } + } else { + if (input[8]) >= (0.0670731738) { + var413 = 0.0472343899 + } else { + var413 = -0.0305471681 + } + } + } else { + if (input[3]) >= (0.00274609635) { + if (input[3]) >= (0.00301910448) { + var413 = 0.0136935115 + } else { + var413 = 0.113360442 + } + } else { + if (input[0]) >= (0.00616541365) { + var413 = -0.125561789 + } else { + var413 = 0.0688862205 + } + } + } + var var414 float64 + if (input[2]) >= (0.0315803811) { + if (input[9]) >= (0.149972558) { + if (input[2]) >= (0.0333519652) { + var414 = 0.0557805188 + } else { + var414 = 0.506626248 + } + } else { + if (input[4]) >= (0.0301120449) { + var414 = 0.0113321673 + } else { + var414 = 0.107743874 + } + } + } else { + if (input[2]) >= (0.0314556584) { + if (input[3]) >= (0.0124516133) { + var414 = -0.0386910364 + } else { + var414 = -0.356502056 + } + } else { + if (input[6]) >= (0.00799289532) { + var414 = 0.00980739854 + } else { + var414 = -0.0106120082 + } + } + } + var var415 float64 + if (input[8]) >= (0.183385789) { + if (input[1]) >= (0.122459352) { + var415 = -0.168610051 + } else { + if (input[3]) >= (0.00853264984) { + var415 = 0.0977729857 + } else { + var415 = -0.136858776 + } + } + } else { + if (input[8]) >= (0.179845273) { + var415 = -0.239372015 + } else { + if (input[1]) >= (0.17454268) { + var415 = 0.0621304773 + } else { + var415 = -0.00110592425 + } + } + } + var var416 float64 + if (input[0]) >= (0.0512781963) { + if (input[8]) >= (0.0298321526) { + if (input[0]) >= (0.0530827045) { + var416 = -0.0119904112 + } else { + var416 = -0.115730427 + } + } else { + if (input[5]) >= (0.00999999978) { + var416 = -0.22598508 + } else { + var416 = 0.0896761119 + } + } + } else { + if (input[8]) >= (0.0297010224) { + if (input[6]) >= (0.0514947176) { + var416 = -0.15410389 + } else { + var416 = 0.0596315935 + } + } else { + if (input[0]) >= (0.041052632) { + var416 = -0.147164002 + } else { + var416 = 0.00316898478 + } + } + } + var var417 float64 + if (input[0]) >= (0.00315789459) { + if (input[4]) >= (0.0147058824) { + if (input[4]) >= (0.0189075638) { + var417 = -0.00414172746 + } else { + var417 = -0.115214571 + } + } else { + if (input[0]) >= (0.00947368424) { + var417 = -0.0529317074 + } else { + var417 = 0.0943100676 + } + } + } else { + if (input[4]) >= (0.0231092442) { + if (input[4]) >= (0.0259103645) { + var417 = 0.0917572752 + } else { + var417 = -0.303095996 + } + } else { + if (input[4]) >= (0.0147058824) { + var417 = 0.134773836 + } else { + var417 = -0.037174467 + } + } + } + var var418 float64 + if (input[9]) >= (0.0427193716) { + if (input[0]) >= (0.123458646) { + if (input[7]) >= (0.00426013768) { + var418 = -0.307036281 + } else { + var418 = 0.23737517 + } + } else { + if (input[8]) >= (0.0719249919) { + var418 = 0.165833026 + } else { + var418 = -0.00563522894 + } + } + } else { + if (input[9]) >= (0.0421130136) { + if (input[7]) >= (0.00456836633) { + var418 = -0.00188457337 + } else { + var418 = 0.341264218 + } + } else { + if (input[8]) >= (0.0175059009) { + var418 = 0.0054735709 + } else { + var418 = 0.0510887578 + } + } + } + var var419 float64 + if (input[1]) >= (0.0292174798) { + if (input[1]) >= (0.0327743888) { + if (input[7]) >= (0.0148419077) { + var419 = 0.025207229 + } else { + var419 = -0.0126484605 + } + } else { + if (input[5]) >= (0.0350000001) { + var419 = -0.128328413 + } else { + var419 = -0.0199847575 + } + } + } else { + if (input[7]) >= (0.0119617889) { + if (input[7]) >= (0.0124498345) { + var419 = -0.00751158688 + } else { + var419 = -0.208496705 + } + } else { + if (input[7]) >= (0.0118295159) { + var419 = 0.50629586 + } else { + var419 = 0.0197989922 + } + } + } + var var420 float64 + if (input[4]) >= (0.55532217) { + if (input[4]) >= (0.558123231) { + if (input[2]) >= (0.0402637199) { + var420 = -0.0882651061 + } else { + var420 = 0.0644690543 + } + } else { + if (input[3]) >= (0.0062601231) { + var420 = -0.360522836 + } else { + var420 = 0.0276708435 + } + } + } else { + if (input[4]) >= (0.479691863) { + if (input[5]) >= (0.0549999997) { + var420 = -0.106024794 + } else { + var420 = 0.199260637 + } + } else { + if (input[4]) >= (0.402661085) { + var420 = -0.0369264632 + } else { + var420 = 0.00517499167 + } + } + } + var var421 float64 + if (input[5]) >= (0.00499999989) { + if (input[0]) >= (0.0233082697) { + if (input[3]) >= (0.00342200743) { + var421 = 0.0124670956 + } else { + var421 = -0.145472005 + } + } else { + if (input[0]) >= (0.0169924796) { + var421 = 0.22890909 + } else { + var421 = 0.0315005332 + } + } + } else { + if (input[0]) >= (0.044661656) { + if (input[0]) >= (0.0491729304) { + var421 = -0.0041286191 + } else { + var421 = 0.160058975 + } + } else { + if (input[1]) >= (0.00940040685) { + var421 = -0.0124826981 + } else { + var421 = -0.458736658 + } + } + } + var var422 float64 + if (input[4]) >= (0.160364151) { + if (input[4]) >= (0.164565831) { + if (input[8]) >= (0.0515997894) { + var422 = -0.0293002259 + } else { + var422 = 0.0114424461 + } + } else { + if (input[0]) >= (0.0512781963) { + var422 = 0.108559296 + } else { + var422 = -0.29985711 + } + } + } else { + if (input[0]) >= (0.0485714301) { + if (input[0]) >= (0.0548872203) { + var422 = 0.00925870147 + } else { + var422 = 0.131680846 + } + } else { + if (input[0]) >= (0.039849624) { + var422 = -0.14427191 + } else { + var422 = 0.000974033843 + } + } + } + var var423 float64 + if (input[6]) >= (0.0556793213) { + if (input[8]) >= (0.0161945969) { + if (input[0]) >= (0.0187969916) { + var423 = 0.0498813055 + } else { + var423 = -0.148272395 + } + } else { + if (input[4]) >= (0.0119047621) { + var423 = 0.201886609 + } else { + var423 = -0.0987117589 + } + } + } else { + if (input[6]) >= (0.0548062734) { + if (input[9]) >= (0.0270118099) { + var423 = -0.374316126 + } else { + var423 = -0.0591321886 + } + } else { + if (input[4]) >= (0.418067217) { + var423 = -0.0309742521 + } else { + var423 = 0.00146370055 + } + } + } + var var424 float64 + if (input[1]) >= (0.0439532511) { + if (input[0]) >= (0.123458646) { + if (input[1]) >= (0.0536077246) { + var424 = 0.00136506686 + } else { + var424 = 0.248087496 + } + } else { + if (input[0]) >= (0.104210526) { + var424 = -0.0964851677 + } else { + var424 = -0.00856979378 + } + } + } else { + if (input[0]) >= (0.123759396) { + if (input[7]) >= (0.0177632719) { + var424 = 0.0167516824 + } else { + var424 = -0.0617834516 + } + } else { + if (input[4]) >= (0.376050413) { + var424 = 0.110599428 + } else { + var424 = 0.00720992824 + } + } + } + var var425 float64 + if (input[9]) >= (0.161940932) { + if (input[2]) >= (0.00256037666) { + if (input[7]) >= (0.00327591924) { + var425 = -0.010956673 + } else { + var425 = -0.117065154 + } + } else { + if (input[0]) >= (0.00676691718) { + var425 = -0.305903941 + } else { + var425 = 0.0682530031 + } + } + } else { + if (input[8]) >= (0.00924468972) { + if (input[8]) >= (0.00976921059) { + var425 = 0.00151305564 + } else { + var425 = -0.0686812848 + } + } else { + if (input[3]) >= (0.00905400887) { + var425 = -0.153720409 + } else { + var425 = 0.126880303 + } + } + } + var var426 float64 + if (input[7]) >= (0.00519152824) { + if (input[0]) >= (0.0163909774) { + if (input[0]) >= (0.0172932334) { + var426 = -0.00730140693 + } else { + var426 = 0.164195508 + } + } else { + if (input[8]) >= (0.0161945969) { + var426 = -0.0871939808 + } else { + var426 = 0.0202718899 + } + } + } else { + if (input[7]) >= (0.00499931723) { + if (input[8]) >= (0.0185549445) { + var426 = 0.2350768 + } else { + var426 = -0.134573191 + } + } else { + if (input[1]) >= (0.063770324) { + var426 = 0.0360491201 + } else { + var426 = -0.00156288443 + } + } + } + var var427 float64 + if (input[4]) >= (0.0889355764) { + if (input[4]) >= (0.0903361365) { + if (input[8]) >= (0.0295698922) { + var427 = 0.00436464883 + } else { + var427 = -0.0307932142 + } + } else { + if (input[1]) >= (0.014989838) { + var427 = -0.402985305 + } else { + var427 = -0.0437235683 + } + } + } else { + if (input[4]) >= (0.0861344561) { + if (input[9]) >= (0.0464008301) { + var427 = 0.372864246 + } else { + var427 = 0.0678508952 + } + } else { + if (input[0]) >= (0.151127815) { + var427 = 0.0780657083 + } else { + var427 = -0.00160973414 + } + } + } + var var428 float64 + if (input[4]) >= (0.0693277344) { + if (input[4]) >= (0.0805322155) { + if (input[4]) >= (0.0833333358) { + var428 = -0.0100670066 + } else { + var428 = 0.0993472934 + } + } else { + if (input[1]) >= (0.0124491863) { + var428 = -0.0263861138 + } else { + var428 = -0.316342205 + } + } + } else { + if (input[6]) >= (0.00796278939) { + if (input[6]) >= (0.00850468129) { + var428 = 0.0176494904 + } else { + var428 = 0.178722695 + } + } else { + if (input[7]) >= (0.00151513552) { + var428 = -0.0334065482 + } else { + var428 = 0.0218246505 + } + } + } + var var429 float64 + if (input[6]) >= (0.275927991) { + var429 = 0.247589931 + } else { + if (input[6]) >= (0.172968656) { + if (input[1]) >= (0.0335365832) { + var429 = -0.281820655 + } else { + var429 = 0.0134199327 + } + } else { + if (input[6]) >= (0.0142848548) { + var429 = 0.0110962335 + } else { + var429 = -0.00308751245 + } + } + } + var var430 float64 + if (input[4]) >= (0.0343137272) { + if (input[4]) >= (0.0385154076) { + if (input[4]) >= (0.0399159677) { + var430 = 0.00272857421 + } else { + var430 = -0.200659484 + } + } else { + if (input[1]) >= (0.0353150405) { + var430 = 0.170455903 + } else { + var430 = -0.00654704077 + } + } + } else { + if (input[6]) >= (0.0702050179) { + if (input[7]) >= (0.00936917402) { + var430 = -0.0650578961 + } else { + var430 = 0.20506376 + } + } else { + if (input[1]) >= (0.0160060972) { + var430 = -0.0251032878 + } else { + var430 = 0.0655686855 + } + } + } + var var431 float64 + if (input[4]) >= (0.0119047621) { + if (input[6]) >= (0.0216304902) { + if (input[5]) >= (0.0249999985) { + var431 = 0.025064623 + } else { + var431 = -0.0210079737 + } + } else { + if (input[6]) >= (0.0175964125) { + var431 = 0.0397852175 + } else { + var431 = 0.00600932958 + } + } + } else { + if (input[7]) >= (0.0017103944) { + if (input[5]) >= (0.0350000001) { + var431 = -0.068045266 + } else { + var431 = -0.352834195 + } + } else { + if (input[0]) >= (0.0127819553) { + var431 = 0.394647837 + } else { + var431 = 0.0300207641 + } + } + } + var var432 float64 + if (input[9]) >= (0.2289868) { + if (input[8]) >= (0.0257671122) { + if (input[3]) >= (0.00485186931) { + var432 = -0.504715562 + } else { + var432 = 0.0933317393 + } + } else { + if (input[2]) >= (0.0103892554) { + var432 = 0.15271461 + } else { + var432 = 0.0177345928 + } + } + } else { + if (input[9]) >= (0.225868389) { + var432 = -0.290398747 + } else { + if (input[5]) >= (0.125) { + var432 = 0.02047248 + } else { + var432 = -0.0048086429 + } + } + } + var var433 float64 + if (input[8]) >= (0.00753999501) { + if (input[3]) >= (0.183460474) { + if (input[3]) >= (0.228100881) { + var433 = 0.0327125192 + } else { + var433 = -0.267993271 + } + } else { + if (input[3]) >= (0.161752015) { + var433 = 0.134741142 + } else { + var433 = 0.000104188926 + } + } + } else { + if (input[7]) >= (0.0105634835) { + var433 = -0.372614086 + } else { + if (input[2]) >= (0.00426329067) { + var433 = 0.0293813627 + } else { + var433 = -0.258490294 + } + } + } + var var434 float64 + if (input[8]) >= (0.00753999501) { + if (input[8]) >= (0.00806451589) { + if (input[4]) >= (0.0119047621) { + var434 = -9.6098549e-05 + } else { + var434 = -0.0371252485 + } + } else { + if (input[4]) >= (0.0259103645) { + var434 = 0.225327268 + } else { + var434 = 0.0469428711 + } + } + } else { + if (input[7]) >= (0.000343988766) { + if (input[0]) >= (0.00616541365) { + var434 = -0.273736447 + } else { + var434 = 0.10790582 + } + } else { + var434 = 0.166883066 + } + } + var var435 float64 + if (input[9]) >= (0.00243986957) { + if (input[9]) >= (0.00252649211) { + if (input[9]) >= (0.0026997372) { + var435 = 0.00020764675 + } else { + var435 = -0.162243411 + } + } else { + if (input[3]) >= (0.0203497857) { + var435 = 0.330074042 + } else { + var435 = 0.0558387712 + } + } + } else { + if (input[0]) >= (0.206766903) { + var435 = -0.273840189 + } else { + if (input[0]) >= (0.174736843) { + var435 = 0.151861653 + } else { + var435 = -0.0407631733 + } + } + } + var var436 float64 + if (input[1]) >= (0.0358231701) { + if (input[0]) >= (0.0524812043) { + if (input[9]) >= (0.125674933) { + var436 = -0.243252516 + } else { + var436 = 0.0147840539 + } + } else { + if (input[0]) >= (0.0512781963) { + var436 = -0.21037215 + } else { + var436 = -0.0135984747 + } + } + } else { + if (input[6]) >= (0.011936659) { + if (input[1]) >= (0.0353150405) { + var436 = 0.157645792 + } else { + var436 = -0.0149474023 + } + } else { + if (input[6]) >= (0.00913688727) { + var436 = 0.0795305073 + } else { + var436 = 0.0127385771 + } + } + } + var var437 float64 + if (input[4]) >= (0.0287114847) { + if (input[0]) >= (0.00375939859) { + if (input[0]) >= (0.00586466165) { + var437 = 0.00157997385 + } else { + var437 = -0.127578139 + } + } else { + if (input[4]) >= (0.0882352963) { + var437 = -0.0978552252 + } else { + var437 = 0.38709861 + } + } + } else { + if (input[4]) >= (0.0273109246) { + if (input[0]) >= (0.00451127812) { + var437 = 0.326018304 + } else { + var437 = -0.334716201 + } + } else { + if (input[1]) >= (0.0241361782) { + var437 = 0.023557866 + } else { + var437 = -0.0612297095 + } + } + } + var var438 float64 + if (input[2]) >= (0.00225827284) { + if (input[4]) >= (0.021708684) { + if (input[5]) >= (0.314999998) { + var438 = -0.0761498809 + } else { + var438 = 0.00236380403 + } + } else { + if (input[1]) >= (0.00889227632) { + var438 = 0.0363603905 + } else { + var438 = -0.250767231 + } + } + } else { + if (input[2]) >= (0.00205506827) { + if (input[8]) >= (0.0119984262) { + var438 = -0.217709675 + } else { + var438 = -0.0334072374 + } + } else { + if (input[9]) >= (0.00571709033) { + var438 = -0.0240999404 + } else { + var438 = 0.157744467 + } + } + } + var var439 float64 + if (input[0]) >= (0.16195488) { + if (input[8]) >= (0.0477970093) { + if (input[9]) >= (0.00781046972) { + var439 = -0.0932577923 + } else { + var439 = 0.0487766936 + } + } else { + if (input[8]) >= (0.0458300561) { + var439 = 0.333604336 + } else { + var439 = 0.00318130595 + } + } + } else { + if (input[0]) >= (0.127969921) { + if (input[0]) >= (0.128270686) { + var439 = 0.0220403224 + } else { + var439 = 0.290054977 + } + } else { + if (input[0]) >= (0.125864655) { + var439 = -0.0768578202 + } else { + var439 = 0.00406166632 + } + } + } + var var440 float64 + if (input[9]) >= (0.118283138) { + if (input[1]) >= (0.0226117894) { + if (input[4]) >= (0.25420171) { + var440 = -0.197089627 + } else { + var440 = 0.017771665 + } + } else { + if (input[4]) >= (0.042717088) { + var440 = 0.296258479 + } else { + var440 = -0.0524784289 + } + } + } else { + if (input[9]) >= (0.116781682) { + if (input[9]) >= (0.117619038) { + var440 = -0.0717417747 + } else { + var440 = -0.363453001 + } + } else { + if (input[7]) >= (1.93023843e-05) { + var440 = -0.00359910214 + } else { + var440 = -0.228088677 + } + } + } + var var441 float64 + if (input[0]) >= (0.0545864664) { + if (input[8]) >= (0.0344217159) { + if (input[3]) >= (0.00312002096) { + var441 = 0.00419211807 + } else { + var441 = -0.120948732 + } + } else { + if (input[0]) >= (0.0587969944) { + var441 = -0.0102117332 + } else { + var441 = -0.246526197 + } + } + } else { + if (input[5]) >= (0.105000004) { + if (input[8]) >= (0.0247180704) { + var441 = 0.0346780978 + } else { + var441 = 0.317534089 + } + } else { + if (input[8]) >= (0.0209152903) { + var441 = 0.0194221828 + } else { + var441 = -0.0131451506 + } + } + } + var var442 float64 + if (input[6]) >= (0.241909266) { + var442 = 0.227395013 + } else { + if (input[6]) >= (0.00152030587) { + if (input[6]) >= (0.00161062111) { + var442 = -0.00554118212 + } else { + var442 = -0.0542112365 + } + } else { + if (input[9]) >= (0.072517544) { + var442 = -0.0702069774 + } else { + var442 = 0.080707714 + } + } + } + var var443 float64 + if (input[0]) >= (0.0100751882) { + if (input[0]) >= (0.0112781953) { + if (input[7]) >= (0.00790849142) { + var443 = 0.00834517088 + } else { + var443 = -0.0135246096 + } + } else { + if (input[2]) >= (0.00520884246) { + var443 = -0.208380058 + } else { + var443 = 0.0684268177 + } + } + } else { + if (input[8]) >= (0.0429451875) { + var443 = 0.271143168 + } else { + if (input[8]) >= (0.0401914492) { + var443 = -0.356711149 + } else { + var443 = 0.019864222 + } + } + } + var var444 float64 + if (input[2]) >= (0.0171488579) { + if (input[8]) >= (0.0144899031) { + if (input[2]) >= (0.017772086) { + var444 = -0.0068546664 + } else { + var444 = -0.0928524584 + } + } else { + if (input[0]) >= (0.0245112777) { + var444 = 0.48992312 + } else { + var444 = 0.0116071049 + } + } + } else { + if (input[6]) >= (0.183791429) { + var444 = 0.405122399 + } else { + if (input[2]) >= (0.0162097141) { + var444 = 0.0613664724 + } else { + var444 = 0.00370050361 + } + } + } + var var445 float64 + if (input[6]) >= (0.281166255) { + var445 = -0.226430088 + } else { + if (input[6]) >= (0.00320618972) { + if (input[6]) >= (0.00329650473) { + var445 = -0.00102043897 + } else { + var445 = -0.149221435 + } + } else { + if (input[9]) >= (0.0018912598) { + var445 = 0.00867262017 + } else { + var445 = 0.202580944 + } + } + } + var var446 float64 + if (input[7]) >= (0.0236685835) { + if (input[8]) >= (0.030750066) { + if (input[2]) >= (0.0385730192) { + var446 = 0.00751217548 + } else { + var446 = -0.0483153537 + } + } else { + if (input[8]) >= (0.0255048517) { + var446 = 0.222317517 + } else { + var446 = 0.0336886533 + } + } + } else { + if (input[2]) >= (0.0386052504) { + if (input[8]) >= (0.0344217159) { + var446 = -0.0431125201 + } else { + var446 = -0.307366401 + } + } else { + if (input[2]) >= (0.0364530869) { + var446 = 0.125611603 + } else { + var446 = -0.00196419773 + } + } + } + var var447 float64 + if (input[7]) >= (0.000281814777) { + if (input[9]) >= (0.000880662934) { + if (input[9]) >= (0.000996159739) { + var447 = 0.00166917895 + } else { + var447 = -0.241016448 + } + } else { + if (input[7]) >= (0.000507957477) { + var447 = 0.0768407211 + } else { + var447 = 0.298983246 + } + } + } else { + if (input[9]) >= (0.0932203382) { + if (input[7]) >= (0.000103013772) { + var447 = -0.140020221 + } else { + var447 = 0.00311265513 + } + } else { + if (input[9]) >= (0.0909970254) { + var447 = 0.432653636 + } else { + var447 = -0.00968709309 + } + } + } + var var448 float64 + if (input[2]) >= (0.0204413719) { + if (input[3]) >= (0.00256942911) { + if (input[3]) >= (0.00412079692) { + var448 = -0.00569260772 + } else { + var448 = -0.0568276234 + } + } else { + if (input[1]) >= (0.0190548785) { + var448 = -0.116745241 + } else { + var448 = 0.276661366 + } + } + } else { + if (input[2]) >= (0.0203192495) { + if (input[9]) >= (0.04621315) { + var448 = -0.0684825182 + } else { + var448 = 0.375986665 + } + } else { + if (input[2]) >= (0.0201640949) { + var448 = -0.185443774 + } else { + var448 = 0.00436164718 + } + } + } + var var449 float64 + if (input[4]) >= (0.430672288) { + if (input[6]) >= (0.00736068888) { + if (input[8]) >= (0.147324935) { + var449 = 0.104897767 + } else { + var449 = -0.10912618 + } + } else { + if (input[6]) >= (0.00504259858) { + var449 = 0.166976511 + } else { + var449 = -0.0210390761 + } + } + } else { + if (input[4]) >= (0.429271698) { + if (input[6]) >= (0.0102808811) { + var449 = 0.262316912 + } else { + var449 = 0.0734885484 + } + } else { + if (input[6]) >= (0.206219703) { + var449 = -0.25067085 + } else { + var449 = 0.00148534204 + } + } + } + var var450 float64 + if (input[1]) >= (0.0114329271) { + if (input[6]) >= (0.0281331837) { + if (input[3]) >= (0.00914526545) { + var450 = 0.0113619203 + } else { + var450 = -0.0512499399 + } + } else { + if (input[6]) >= (0.0267182477) { + var450 = 0.0806003362 + } else { + var450 = 0.00265205884 + } + } + } else { + if (input[5]) >= (0.175000012) { + if (input[5]) >= (0.215000004) { + var450 = 0.0239382256 + } else { + var450 = -0.369645 + } + } else { + if (input[0]) >= (0.143308282) { + var450 = 0.127770543 + } else { + var450 = 0.00618122984 + } + } + } + var var451 float64 + if (input[6]) >= (0.0305114854) { + if (input[6]) >= (0.0310232714) { + if (input[4]) >= (0.0721288547) { + var451 = -0.00637228973 + } else { + var451 = 0.0565072559 + } + } else { + if (input[3]) >= (0.00593246287) { + var451 = 0.100131668 + } else { + var451 = 0.599393249 + } + } + } else { + if (input[6]) >= (0.0302405395) { + if (input[0]) >= (0.0377443582) { + var451 = -0.436773986 + } else { + var451 = -0.0386145785 + } + } else { + if (input[6]) >= (0.0300298035) { + var451 = 0.220320538 + } else { + var451 = -0.00299347029 + } + } + } + var var452 float64 + if (input[9]) >= (0.12326394) { + if (input[9]) >= (0.124404475) { + if (input[8]) >= (0.0167191196) { + var452 = 0.0607315935 + } else { + var452 = -0.00968139339 + } + } else { + if (input[1]) >= (0.0419207327) { + var452 = 0.560121119 + } else { + var452 = -0.0127385352 + } + } + } else { + if (input[9]) >= (0.118918374) { + if (input[3]) >= (0.00326898089) { + var452 = -0.20992811 + } else { + var452 = 0.130762294 + } + } else { + if (input[9]) >= (0.118254267) { + var452 = 0.280099571 + } else { + var452 = 0.000291149336 + } + } + } + var var453 float64 + if (input[6]) >= (0.0506216697) { + if (input[4]) >= (0.0245098043) { + if (input[0]) >= (0.039849624) { + var453 = 0.0534924045 + } else { + var453 = -0.0495258756 + } + } else { + if (input[1]) >= (0.0434451215) { + var453 = 0.312670469 + } else { + var453 = 0.0577085465 + } + } + } else { + if (input[6]) >= (0.0452930704) { + if (input[1]) >= (0.0165142268) { + var453 = -0.114393562 + } else { + var453 = 0.164953575 + } + } else { + if (input[6]) >= (0.0446909741) { + var453 = 0.17468226 + } else { + var453 = -0.00570970355 + } + } + } + var var454 float64 + if (input[9]) >= (0.0169635899) { + if (input[8]) >= (0.127261996) { + if (input[7]) >= (0.0246412195) { + var454 = 0.0173132271 + } else { + var454 = 0.26751402 + } + } else { + if (input[9]) >= (0.0170502122) { + var454 = 0.000714324124 + } else { + var454 = 0.233119145 + } + } + } else { + if (input[8]) >= (0.0255048517) { + if (input[2]) >= (0.0058588963) { + var454 = -0.0115113901 + } else { + var454 = 0.149955913 + } + } else { + if (input[7]) >= (0.000339518767) { + var454 = -0.11513558 + } else { + var454 = 0.0304798558 + } + } + } + var var455 float64 + if (input[6]) >= (0.00967877917) { + if (input[7]) >= (0.305889964) { + var455 = 0.224451512 + } else { + if (input[8]) >= (0.0648439527) { + var455 = -0.0292856414 + } else { + var455 = -0.00217652204 + } + } + } else { + if (input[7]) >= (0.000293193036) { + if (input[7]) >= (0.000314730452) { + var455 = 0.0126407184 + } else { + var455 = 0.178566426 + } + } else { + if (input[5]) >= (0.0249999985) { + var455 = -0.121024691 + } else { + var455 = -0.0152886184 + } + } + } + var var456 float64 + if (input[1]) >= (0.0266768299) { + if (input[1]) >= (0.0292174798) { + if (input[0]) >= (0.0485714301) { + var456 = 0.0155858276 + } else { + var456 = -0.00803255104 + } + } else { + if (input[6]) >= (0.00272450852) { + var456 = 0.0225911327 + } else { + var456 = 0.172292203 + } + } + } else { + if (input[0]) >= (0.00526315812) { + if (input[8]) >= (0.0155389458) { + var456 = -0.00825168565 + } else { + var456 = -0.139609292 + } + } else { + if (input[6]) >= (0.00212240731) { + var456 = 0.189618617 + } else { + var456 = -0.129950717 + } + } + } + var var457 float64 + if (input[7]) >= (0.0373119116) { + if (input[7]) >= (0.0375569537) { + if (input[0]) >= (0.17488721) { + var457 = -0.104299583 + } else { + var457 = -0.00133823464 + } + } else { + if (input[2]) >= (0.0520391725) { + var457 = -0.138837144 + } else { + var457 = -0.488717318 + } + } + } else { + if (input[7]) >= (0.0324190632) { + if (input[1]) >= (0.0505589433) { + var457 = -0.0948911235 + } else { + var457 = 0.105591632 + } + } else { + if (input[7]) >= (0.0289562158) { + var457 = -0.0534072779 + } else { + var457 = 0.00414584251 + } + } + } + var var458 float64 + if (input[0]) >= (0.0145864664) { + if (input[8]) >= (0.0185549445) { + if (input[4]) >= (0.032913167) { + var458 = -0.00403854437 + } else { + var458 = 0.0662125275 + } + } else { + if (input[7]) >= (0.00813117996) { + var458 = 0.0394047946 + } else { + var458 = -0.118966401 + } + } + } else { + if (input[4]) >= (0.0357142873) { + if (input[1]) >= (0.0922256112) { + var458 = -0.124854438 + } else { + var458 = 0.0843159482 + } + } else { + if (input[0]) >= (0.00977443624) { + var458 = -0.225659668 + } else { + var458 = 0.00616453588 + } + } + } + var var459 float64 + if (input[4]) >= (0.188375354) { + if (input[0]) >= (0.0317293257) { + if (input[5]) >= (0.00999999978) { + var459 = -0.0361337811 + } else { + var459 = 0.0220705159 + } + } else { + if (input[1]) >= (0.023119919) { + var459 = 0.0203009974 + } else { + var459 = 0.309823543 + } + } + } else { + if (input[4]) >= (0.186974794) { + if (input[0]) >= (0.0285714287) { + var459 = -0.159044936 + } else { + var459 = -0.779089928 + } + } else { + if (input[5]) >= (0.00499999989) { + var459 = 0.0221779849 + } else { + var459 = -0.0116271162 + } + } + } + var var460 float64 + if (input[3]) >= (0.0421983227) { + if (input[2]) >= (0.0735386088) { + if (input[2]) >= (0.0853018463) { + var460 = 0.0301501472 + } else { + var460 = -0.15825361 + } + } else { + if (input[9]) >= (0.000591921038) { + var460 = 0.0990440622 + } else { + var460 = -0.273701251 + } + } + } else { + if (input[3]) >= (0.04151351) { + var460 = -0.251160383 + } else { + if (input[5]) >= (0.435000002) { + var460 = -0.0932336897 + } else { + var460 = 0.00417929096 + } + } + } + var var461 float64 + if (input[1]) >= (0.187245935) { + if (input[1]) >= (0.19385162) { + if (input[1]) >= (0.202489838) { + var461 = 0.0845308378 + } else { + var461 = -0.126945153 + } + } else { + if (input[9]) >= (0.00983166322) { + var461 = 0.33401075 + } else { + var461 = 0.0425357409 + } + } + } else { + if (input[9]) >= (0.000187682264) { + if (input[1]) >= (0.158282518) { + var461 = -0.0888675228 + } else { + var461 = -0.00481701503 + } + } else { + var461 = 0.236847982 + } + } + var var462 float64 + if (input[9]) >= (0.00893656351) { + if (input[9]) >= (0.010351399) { + if (input[9]) >= (0.010466896) { + var462 = -0.000321168103 + } else { + var462 = 0.165368989 + } + } else { + if (input[9]) >= (0.0100049088) { + var462 = -0.197088018 + } else { + var462 = -0.00759536587 + } + } + } else { + if (input[1]) >= (0.0973069072) { + if (input[1]) >= (0.108993903) { + var462 = 0.0413332619 + } else { + var462 = 0.171830878 + } + } else { + if (input[1]) >= (0.0276930891) { + var462 = -0.0100546936 + } else { + var462 = 0.0593817011 + } + } + } + var var463 float64 + if (input[6]) >= (0.103817321) { + if (input[0]) >= (0.0264661647) { + if (input[0]) >= (0.0542857125) { + var463 = -0.0905853286 + } else { + var463 = 0.212569788 + } + } else { + if (input[8]) >= (0.0186860748) { + var463 = -0.427489311 + } else { + var463 = 0.000320627762 + } + } + } else { + if (input[6]) >= (0.100836918) { + if (input[0]) >= (0.0303759389) { + var463 = 0.425610334 + } else { + var463 = 0.154946104 + } + } else { + if (input[6]) >= (0.0952674896) { + var463 = -0.15282619 + } else { + var463 = -0.00197628932 + } + } + } + var var464 float64 + if (input[6]) >= (0.103576481) { + if (input[3]) >= (0.00252875732) { + if (input[3]) >= (0.010206541) { + var464 = 0.00737449294 + } else { + var464 = -0.210378304 + } + } else { + if (input[3]) >= (0.00210806029) { + var464 = 0.20995748 + } else { + var464 = -0.0379850268 + } + } + } else { + if (input[6]) >= (0.100761652) { + var464 = 0.265030205 + } else { + if (input[6]) >= (0.0953126401) { + var464 = -0.192762926 + } else { + var464 = -0.0006739542 + } + } + } + var var465 float64 + if (input[3]) >= (0.022961922) { + if (input[8]) >= (0.0660241246) { + if (input[8]) >= (0.077694729) { + var465 = 0.016990982 + } else { + var465 = 0.10983979 + } + } else { + if (input[4]) >= (0.324229717) { + var465 = -0.164873958 + } else { + var465 = -0.00152604922 + } + } + } else { + if (input[8]) >= (0.12922895) { + if (input[3]) >= (0.022030795) { + var465 = 0.278090626 + } else { + var465 = 0.00754145905 + } + } else { + if (input[8]) >= (0.119000785) { + var465 = -0.208571732 + } else { + var465 = -0.00314086187 + } + } + } + var var466 float64 + if (input[2]) >= (0.187716514) { + if (input[4]) >= (0.278011203) { + if (input[3]) >= (0.0160602015) { + var466 = -0.00573164178 + } else { + var466 = 0.345350415 + } + } else { + if (input[1]) >= (0.123729676) { + var466 = -0.322551519 + } else { + var466 = -0.0994874388 + } + } + } else { + if (input[2]) >= (0.184880257) { + var466 = 0.276318043 + } else { + if (input[0]) >= (0.0284210518) { + var466 = -0.00528382137 + } else { + var466 = 0.00847751368 + } + } + } + var var467 float64 + if (input[9]) >= (0.144356534) { + if (input[1]) >= (0.0439532511) { + if (input[9]) >= (0.211315796) { + var467 = -0.0336404182 + } else { + var467 = -0.141785771 + } + } else { + if (input[6]) >= (0.00438028714) { + var467 = -0.0431789495 + } else { + var467 = 0.0485368669 + } + } + } else { + if (input[9]) >= (0.141440243) { + if (input[7]) >= (0.00214642496) { + var467 = 0.0286062378 + } else { + var467 = 0.273606569 + } + } else { + if (input[6]) >= (0.00678869244) { + var467 = 0.00600273767 + } else { + var467 = -0.0102653466 + } + } + } + var var468 float64 + if (input[8]) >= (0.00675321277) { + if (input[8]) >= (0.0731051639) { + if (input[8]) >= (0.0749409944) { + var468 = -0.00466977106 + } else { + var468 = -0.146147266 + } + } else { + if (input[0]) >= (0.124060154) { + var468 = 0.0491609238 + } else { + var468 = 0.00065317651 + } + } + } else { + if (input[0]) >= (0.0293233097) { + var468 = -0.410158098 + } else { + if (input[8]) >= (0.00150799891) { + var468 = -0.0724337325 + } else { + var468 = 0.182266802 + } + } + } + var var469 float64 + if (input[9]) >= (0.000476424233) { + if (input[4]) >= (0.660364151) { + if (input[2]) >= (0.1565938) { + var469 = -0.0358539224 + } else { + var469 = -0.207148507 + } + } else { + if (input[1]) >= (0.0988313034) { + var469 = 0.0295992773 + } else { + var469 = 0.00274781347 + } + } + } else { + if (input[2]) >= (0.0330486596) { + if (input[1]) >= (0.0983231738) { + var469 = -0.161217719 + } else { + var469 = 0.16462563 + } + } else { + if (input[4]) >= (0.158963591) { + var469 = -0.306572855 + } else { + var469 = -0.0228669606 + } + } + } + var var470 float64 + if (input[8]) >= (0.0993312374) { + if (input[0]) >= (0.0600000024) { + if (input[0]) >= (0.113233082) { + var470 = 0.0178466011 + } else { + var470 = 0.172625929 + } + } else { + if (input[7]) >= (0.0210731234) { + var470 = -0.480774254 + } else { + var470 = 0.0451867357 + } + } + } else { + if (input[5]) >= (0.555000007) { + if (input[7]) >= (0.12187545) { + var470 = -0.0686971471 + } else { + var470 = 0.242208228 + } + } else { + if (input[5]) >= (0.204999998) { + var470 = -0.0977838039 + } else { + var470 = 0.00205273926 + } + } + } + var var471 float64 + if (input[5]) >= (0.164999992) { + if (input[6]) >= (0.00344703021) { + if (input[1]) >= (0.0129573178) { + var471 = 0.0275645331 + } else { + var471 = -0.0830044374 + } + } else { + if (input[3]) >= (0.0226312093) { + var471 = 0.0320866182 + } else { + var471 = 0.242563263 + } + } + } else { + if (input[1]) >= (0.210619926) { + if (input[9]) >= (0.0358906239) { + var471 = 0.0854021385 + } else { + var471 = -0.17387113 + } + } else { + if (input[5]) >= (0.155000001) { + var471 = -0.140285254 + } else { + var471 = -0.00181985449 + } + } + } + var var472 float64 + if (input[6]) >= (0.00155041087) { + if (input[1]) >= (0.0205792673) { + if (input[1]) >= (0.023119919) { + var472 = 0.00478623388 + } else { + var472 = 0.0489381403 + } + } else { + if (input[4]) >= (0.223389357) { + var472 = -0.0637496263 + } else { + var472 = 0.000535166997 + } + } + } else { + if (input[7]) >= (0.038976796) { + if (input[7]) >= (0.0514213443) { + var472 = -0.0606999137 + } else { + var472 = -0.399416 + } + } else { + if (input[1]) >= (0.0119410567) { + var472 = -0.014554752 + } else { + var472 = -0.25328508 + } + } + } + var var473 float64 + if (input[0]) >= (0.0368421078) { + if (input[8]) >= (0.0329792798) { + if (input[4]) >= (0.0917366967) { + var473 = 0.00526069989 + } else { + var473 = -0.0473421812 + } + } else { + if (input[4]) >= (0.182773113) { + var473 = 0.0436187424 + } else { + var473 = -0.0922588706 + } + } + } else { + if (input[9]) >= (0.0413911566) { + if (input[9]) >= (0.0421130136) { + var473 = -0.006300434 + } else { + var473 = -0.229396001 + } + } else { + if (input[8]) >= (0.0261605028) { + var473 = 0.0692826211 + } else { + var473 = 0.00752965128 + } + } + } + var var474 float64 + if (input[2]) >= (0.0380082503) { + if (input[0]) >= (0.0148872184) { + if (input[2]) >= (0.0389548056) { + var474 = -0.00463340105 + } else { + var474 = -0.134036988 + } + } else { + if (input[5]) >= (0.0249999985) { + var474 = 0.143035114 + } else { + var474 = -0.267157763 + } + } + } else { + if (input[2]) >= (0.0378727168) { + var474 = 0.471262902 + } else { + if (input[3]) >= (0.041359216) { + var474 = 0.206892118 + } else { + var474 = -0.000387900072 + } + } + } + var var475 float64 + if (input[7]) >= (0.0345973894) { + if (input[4]) >= (0.464285731) { + if (input[9]) >= (0.00492305029) { + var475 = -0.1234833 + } else { + var475 = 0.137865752 + } + } else { + if (input[4]) >= (0.376050413) { + var475 = 0.129444465 + } else { + var475 = 0.0135915317 + } + } + } else { + if (input[7]) >= (0.0344795436) { + var475 = -0.29821682 + } else { + if (input[1]) >= (0.0114329271) { + var475 = -0.00353855384 + } else { + var475 = 0.0333926529 + } + } + } + var var476 float64 + if (input[8]) >= (0.0102937315) { + if (input[9]) >= (0.407602549) { + if (input[6]) >= (0.011575399) { + var476 = -0.0868224353 + } else { + var476 = 0.178752124 + } + } else { + if (input[0]) >= (0.00406015012) { + var476 = 0.000436461647 + } else { + var476 = -0.0537494831 + } + } + } else { + if (input[5]) >= (0.00499999989) { + if (input[8]) >= (0.00950695015) { + var476 = -0.348682612 + } else { + var476 = -0.144532382 + } + } else { + if (input[0]) >= (0.00255639106) { + var476 = 0.0670757666 + } else { + var476 = -0.0520166568 + } + } + } + var var477 float64 + if (input[8]) >= (0.0824154243) { + if (input[4]) >= (0.0693277344) { + if (input[4]) >= (0.402661085) { + var477 = -0.0268900972 + } else { + var477 = 0.0528296083 + } + } else { + if (input[7]) >= (0.0431778058) { + var477 = -0.234595641 + } else { + var477 = 0.0509880483 + } + } + } else { + if (input[8]) >= (0.0793994218) { + if (input[4]) >= (0.278711498) { + var477 = 5.54362887e-05 + } else { + var477 = -0.224362731 + } + } else { + if (input[5]) >= (0.105000004) { + var477 = 0.0389812961 + } else { + var477 = -0.00448713964 + } + } + } + var var478 float64 + if (input[0]) >= (0.121654138) { + if (input[5]) >= (0.0450000018) { + if (input[5]) >= (0.075000003) { + var478 = -0.00628152769 + } else { + var478 = 0.117324613 + } + } else { + if (input[1]) >= (0.0134654474) { + var478 = -0.0660713911 + } else { + var478 = 0.0329159684 + } + } + } else { + if (input[0]) >= (0.12045113) { + if (input[1]) >= (0.0409044698) { + var478 = -0.0180103686 + } else { + var478 = 0.158599913 + } + } else { + if (input[0]) >= (0.11383459) { + var478 = -0.10409902 + } else { + var478 = 0.00160641596 + } + } + } + var var479 float64 + if (input[0]) >= (0.12105263) { + if (input[4]) >= (0.408263326) { + if (input[0]) >= (0.124661654) { + var479 = -0.0103037329 + } else { + var479 = 0.187138572 + } + } else { + if (input[0]) >= (0.123157896) { + var479 = -0.0140926261 + } else { + var479 = -0.112712115 + } + } + } else { + if (input[0]) >= (0.12045113) { + if (input[1]) >= (0.0429369919) { + var479 = -0.0356319696 + } else { + var479 = 0.252851188 + } + } else { + if (input[4]) >= (0.380252123) { + var479 = -0.0788752437 + } else { + var479 = 0.00321473135 + } + } + } + var var480 float64 + if (input[7]) >= (0.0581948571) { + if (input[5]) >= (0.0249999985) { + if (input[4]) >= (0.587535024) { + var480 = 0.45017314 + } else { + var480 = 0.0537344441 + } + } else { + if (input[4]) >= (0.181372553) { + var480 = -0.0650059804 + } else { + var480 = 0.0744697228 + } + } + } else { + if (input[7]) >= (0.0552235097) { + if (input[4]) >= (0.30112046) { + var480 = 0.0471591763 + } else { + var480 = -0.274711579 + } + } else { + if (input[7]) >= (0.0547080338) { + var480 = 0.259785205 + } else { + var480 = -0.00314824679 + } + } + } + var var481 float64 + if (input[3]) >= (0.00250460859) { + if (input[0]) >= (0.084360905) { + if (input[4]) >= (0.0287114847) { + var481 = -0.00310158404 + } else { + var481 = -0.125213638 + } + } else { + if (input[8]) >= (0.0602543913) { + var481 = 0.0663705021 + } else { + var481 = 0.00429317215 + } + } + } else { + if (input[0]) >= (0.00586466165) { + if (input[7]) >= (0.00214662822) { + var481 = -0.0396725014 + } else { + var481 = -0.186569348 + } + } else { + if (input[9]) >= (0.0830999315) { + var481 = 0.134739384 + } else { + var481 = -0.0920131207 + } + } + } + var var482 float64 + if (input[4]) >= (0.441876769) { + if (input[5]) >= (0.0949999988) { + if (input[8]) >= (0.158471018) { + var482 = 0.0762743056 + } else { + var482 = -0.169294029 + } + } else { + if (input[4]) >= (0.572128892) { + var482 = -0.0155747896 + } else { + var482 = 0.116017126 + } + } + } else { + if (input[4]) >= (0.436274529) { + if (input[2]) >= (0.0678152442) { + var482 = 0.186370522 + } else { + var482 = -0.242678329 + } + } else { + if (input[8]) >= (0.16869919) { + var482 = -0.0740737095 + } else { + var482 = -0.000659798039 + } + } + } + var var483 float64 + if (input[4]) >= (0.14915967) { + if (input[4]) >= (0.15056023) { + if (input[5]) >= (0.185000002) { + var483 = 0.0539085194 + } else { + var483 = -0.00971093401 + } + } else { + if (input[1]) >= (0.0307418704) { + var483 = 0.0327795558 + } else { + var483 = -0.584495127 + } + } + } else { + if (input[4]) >= (0.143557429) { + if (input[2]) >= (0.101363212) { + var483 = -0.246674657 + } else { + var483 = 0.167479128 + } + } else { + if (input[7]) >= (0.246649504) { + var483 = -0.241754234 + } else { + var483 = 0.00335645932 + } + } + } + var var484 float64 + if (input[1]) >= (0.127794713) { + if (input[1]) >= (0.129827231) { + if (input[9]) >= (0.0538503751) { + var484 = -0.120428175 + } else { + var484 = 0.0423765294 + } + } else { + if (input[4]) >= (0.103641458) { + var484 = 0.0672732368 + } else { + var484 = 0.394706458 + } + } + } else { + if (input[1]) >= (0.125254065) { + if (input[9]) >= (0.0460399054) { + var484 = 0.166500866 + } else { + var484 = -0.311539114 + } + } else { + if (input[1]) >= (0.121697158) { + var484 = 0.108770475 + } else { + var484 = -0.000733454013 + } + } + } + var var485 float64 + if (input[4]) >= (0.465686262) { + if (input[5]) >= (0.0149999997) { + if (input[8]) >= (0.0567138717) { + var485 = -0.0628554225 + } else { + var485 = 0.325379014 + } + } else { + if (input[4]) >= (0.572829127) { + var485 = -0.0342799537 + } else { + var485 = 0.159740359 + } + } + } else { + if (input[4]) >= (0.45028013) { + if (input[9]) >= (0.0222620033) { + var485 = 0.0535941087 + } else { + var485 = -0.212369516 + } + } else { + if (input[5]) >= (0.894999981) { + var485 = -0.170840085 + } else { + var485 = -0.00201578694 + } + } + } + var var486 float64 + if (input[6]) >= (0.0926784426) { + if (input[8]) >= (0.0329137146) { + if (input[7]) >= (0.00248188013) { + var486 = 0.0872122347 + } else { + var486 = -0.213173613 + } + } else { + if (input[4]) >= (0.0483193286) { + var486 = 0.24719879 + } else { + var486 = -0.017270254 + } + } + } else { + if (input[9]) >= (0.475817859) { + if (input[2]) >= (0.00473516528) { + var486 = -0.186792731 + } else { + var486 = 0.019966023 + } + } else { + if (input[9]) >= (0.405263782) { + var486 = 0.111017331 + } else { + var486 = 0.00243958505 + } + } + } + var var487 float64 + if (input[1]) >= (0.0759654492) { + if (input[3]) >= (0.00667319447) { + if (input[3]) >= (0.00803111773) { + var487 = 0.0150724286 + } else { + var487 = -0.257510126 + } + } else { + if (input[7]) >= (0.000569928263) { + var487 = 0.00983070396 + } else { + var487 = 0.388957232 + } + } + } else { + if (input[0]) >= (0.0485714301) { + if (input[3]) >= (0.0030018189) { + var487 = -0.000795692438 + } else { + var487 = 0.0929303169 + } + } else { + if (input[3]) >= (0.0096104471) { + var487 = -0.0697733015 + } else { + var487 = -0.00412932551 + } + } + } + var var488 float64 + if (input[7]) >= (0.00038421902) { + if (input[7]) >= (0.000443954836) { + if (input[7]) >= (0.000452488486) { + var488 = -0.00197839993 + } else { + var488 = 0.297818631 + } + } else { + if (input[7]) >= (0.000417541014) { + var488 = -0.207232907 + } else { + var488 = -0.0321596153 + } + } + } else { + if (input[7]) >= (0.00037568534) { + if (input[3]) >= (0.0110240402) { + var488 = 0.420200437 + } else { + var488 = 0.104380876 + } + } else { + if (input[3]) >= (0.002779142) { + var488 = 0.0230998714 + } else { + var488 = -0.0820677876 + } + } + } + var var489 float64 + if (input[1]) >= (0.15675813) { + if (input[4]) >= (0.15476191) { + if (input[7]) >= (0.000272874749) { + var489 = 0.079492569 + } else { + var489 = -0.1500974 + } + } else { + if (input[7]) >= (9.59023746e-05) { + var489 = -0.149437338 + } else { + var489 = 0.26772359 + } + } + } else { + if (input[1]) >= (0.151676834) { + if (input[6]) >= (0.00581027754) { + var489 = 0.198325813 + } else { + var489 = -0.102935612 + } + } else { + if (input[6]) >= (0.133651435) { + var489 = 0.101128705 + } else { + var489 = 0.00096241862 + } + } + } + var var490 float64 + if (input[8]) >= (0.100249149) { + if (input[0]) >= (0.130977452) { + if (input[5]) >= (0.234999999) { + var490 = 0.106701642 + } else { + var490 = -0.0526291355 + } + } else { + if (input[2]) >= (0.0323165245) { + var490 = 0.10182143 + } else { + var490 = -0.0252851713 + } + } + } else { + if (input[9]) >= (0.00749285333) { + if (input[9]) >= (0.00859007239) { + var490 = 0.000166409707 + } else { + var490 = 0.0774247646 + } + } else { + if (input[7]) >= (0.00717825163) { + var490 = 0.0308562927 + } else { + var490 = -0.0584115423 + } + } + } + var var491 float64 + if (input[0]) >= (0.0813533813) { + if (input[8]) >= (0.0169813801) { + if (input[6]) >= (0.00185146159) { + var491 = -0.00633856049 + } else { + var491 = -0.0995935798 + } + } else { + var491 = -0.319200367 + } + } else { + if (input[0]) >= (0.0786466151) { + if (input[5]) >= (0.0149999997) { + var491 = -0.12226069 + } else { + var491 = 0.197382256 + } + } else { + if (input[4]) >= (0.268207312) { + var491 = 0.0514911972 + } else { + var491 = 0.000866933784 + } + } + } + var var492 float64 + if (input[1]) >= (0.00685975607) { + if (input[4]) >= (0.107142858) { + if (input[4]) >= (0.108543418) { + var492 = -0.00423673447 + } else { + var492 = -0.267282575 + } + } else { + if (input[1]) >= (0.0160060972) { + var492 = 0.000266687595 + } else { + var492 = 0.0529088415 + } + } + } else { + if (input[4]) >= (0.14635855) { + if (input[3]) >= (0.00383482454) { + var492 = -0.142914876 + } else { + var492 = 0.13865152 + } + } else { + if (input[4]) >= (0.0441176482) { + var492 = -0.182959408 + } else { + var492 = 0.0497040674 + } + } + } + var var493 float64 + if (input[4]) >= (0.00490196096) { + if (input[4]) >= (0.0119047621) { + if (input[9]) >= (0.294906616) { + var493 = -0.0492320731 + } else { + var493 = 0.000822217145 + } + } else { + if (input[7]) >= (0.000344395172) { + var493 = -0.083902806 + } else { + var493 = 0.0968329161 + } + } + } else { + if (input[9]) >= (0.0128490161) { + if (input[7]) >= (0.0172156952) { + var493 = 0.104243062 + } else { + var493 = 0.257907242 + } + } else { + if (input[7]) >= (0.0371341258) { + var493 = 0.179313838 + } else { + var493 = -0.152418166 + } + } + } + var var494 float64 + if (input[2]) >= (0.00465848856) { + if (input[2]) >= (0.00468011014) { + if (input[2]) >= (0.00547791272) { + var494 = -0.000445411308 + } else { + var494 = 0.0564623922 + } + } else { + var494 = 0.453841954 + } + } else { + if (input[2]) >= (0.0046112407) { + if (input[9]) >= (0.125747114) { + var494 = -0.0772032663 + } else { + var494 = -0.299265951 + } + } else { + if (input[9]) >= (0.0323390998) { + var494 = -0.00411211979 + } else { + var494 = -0.0631354675 + } + } + } + var var495 float64 + if (input[2]) >= (0.470134735) { + var495 = -0.223825037 + } else { + if (input[9]) >= (0.246383518) { + if (input[4]) >= (0.0175070036) { + var495 = -0.0671552271 + } else { + var495 = 0.102772444 + } + } else { + if (input[9]) >= (0.238573045) { + var495 = 0.156644702 + } else { + var495 = 0.00248850253 + } + } + } + var var496 float64 + if (input[4]) >= (0.304621875) { + if (input[5]) >= (0.254999995) { + if (input[2]) >= (0.182350919) { + var496 = -0.0197010636 + } else { + var496 = -0.330768526 + } + } else { + if (input[1]) >= (0.0139735769) { + var496 = 0.00660737185 + } else { + var496 = -0.127055123 + } + } + } else { + if (input[5]) >= (0.284999996) { + if (input[5]) >= (0.675000012) { + var496 = -0.07162413 + } else { + var496 = 0.144766897 + } + } else { + if (input[4]) >= (0.299019635) { + var496 = 0.131504044 + } else { + var496 = 0.00431525521 + } + } + } + var var497 float64 + if (input[1]) >= (0.170477644) { + if (input[6]) >= (0.00525333406) { + if (input[1]) >= (0.18064025) { + var497 = -0.062293373 + } else { + var497 = 0.174499243 + } + } else { + if (input[7]) >= (0.000270842924) { + var497 = 0.232616261 + } else { + var497 = -0.0776687711 + } + } + } else { + if (input[1]) >= (0.165396348) { + if (input[4]) >= (0.085434176) { + var497 = -0.066631265 + } else { + var497 = -0.333392918 + } + } else { + if (input[1]) >= (0.0358231701) { + var497 = -0.0073480811 + } else { + var497 = 0.0037356175 + } + } + } + var var498 float64 + if (input[8]) >= (0.148373991) { + if (input[0]) >= (0.221503764) { + var498 = -0.212517485 + } else { + if (input[0]) >= (0.208270669) { + var498 = 0.247572884 + } else { + var498 = 0.0408139564 + } + } + } else { + if (input[8]) >= (0.143391028) { + if (input[0]) >= (0.12556392) { + var498 = -0.298463106 + } else { + var498 = -0.0203433987 + } + } else { + if (input[2]) >= (0.220409825) { + var498 = 0.0892436579 + } else { + var498 = -0.00381614012 + } + } + } + var var499 float64 + if (input[8]) >= (0.00570417009) { + if (input[5]) >= (0.215000004) { + if (input[0]) >= (0.0768421069) { + var499 = -0.0564594343 + } else { + var499 = 0.148705289 + } + } else { + if (input[2]) >= (0.000740545336) { + var499 = 0.00202492182 + } else { + var499 = 0.0936344117 + } + } + } else { + if (input[9]) >= (0.0425750017) { + var499 = -0.317553043 + } else { + if (input[1]) >= (0.152693093) { + var499 = -0.0285214316 + } else { + var499 = 0.175136536 + } + } + } + var var500 float64 + var500 = 1 / (1 + math.Exp((0)-(var0+var1+var2+var3+var4+var5+var6+var7+var8+var9+var10+var11+var12+var13+var14+var15+var16+var17+var18+var19+var20+var21+var22+var23+var24+var25+var26+var27+var28+var29+var30+var31+var32+var33+var34+var35+var36+var37+var38+var39+var40+var41+var42+var43+var44+var45+var46+var47+var48+var49+var50+var51+var52+var53+var54+var55+var56+var57+var58+var59+var60+var61+var62+var63+var64+var65+var66+var67+var68+var69+var70+var71+var72+var73+var74+var75+var76+var77+var78+var79+var80+var81+var82+var83+var84+var85+var86+var87+var88+var89+var90+var91+var92+var93+var94+var95+var96+var97+var98+var99+var100+var101+var102+var103+var104+var105+var106+var107+var108+var109+var110+var111+var112+var113+var114+var115+var116+var117+var118+var119+var120+var121+var122+var123+var124+var125+var126+var127+var128+var129+var130+var131+var132+var133+var134+var135+var136+var137+var138+var139+var140+var141+var142+var143+var144+var145+var146+var147+var148+var149+var150+var151+var152+var153+var154+var155+var156+var157+var158+var159+var160+var161+var162+var163+var164+var165+var166+var167+var168+var169+var170+var171+var172+var173+var174+var175+var176+var177+var178+var179+var180+var181+var182+var183+var184+var185+var186+var187+var188+var189+var190+var191+var192+var193+var194+var195+var196+var197+var198+var199+var200+var201+var202+var203+var204+var205+var206+var207+var208+var209+var210+var211+var212+var213+var214+var215+var216+var217+var218+var219+var220+var221+var222+var223+var224+var225+var226+var227+var228+var229+var230+var231+var232+var233+var234+var235+var236+var237+var238+var239+var240+var241+var242+var243+var244+var245+var246+var247+var248+var249+var250+var251+var252+var253+var254+var255+var256+var257+var258+var259+var260+var261+var262+var263+var264+var265+var266+var267+var268+var269+var270+var271+var272+var273+var274+var275+var276+var277+var278+var279+var280+var281+var282+var283+var284+var285+var286+var287+var288+var289+var290+var291+var292+var293+var294+var295+var296+var297+var298+var299+var300+var301+var302+var303+var304+var305+var306+var307+var308+var309+var310+var311+var312+var313+var314+var315+var316+var317+var318+var319+var320+var321+var322+var323+var324+var325+var326+var327+var328+var329+var330+var331+var332+var333+var334+var335+var336+var337+var338+var339+var340+var341+var342+var343+var344+var345+var346+var347+var348+var349+var350+var351+var352+var353+var354+var355+var356+var357+var358+var359+var360+var361+var362+var363+var364+var365+var366+var367+var368+var369+var370+var371+var372+var373+var374+var375+var376+var377+var378+var379+var380+var381+var382+var383+var384+var385+var386+var387+var388+var389+var390+var391+var392+var393+var394+var395+var396+var397+var398+var399+var400+var401+var402+var403+var404+var405+var406+var407+var408+var409+var410+var411+var412+var413+var414+var415+var416+var417+var418+var419+var420+var421+var422+var423+var424+var425+var426+var427+var428+var429+var430+var431+var432+var433+var434+var435+var436+var437+var438+var439+var440+var441+var442+var443+var444+var445+var446+var447+var448+var449+var450+var451+var452+var453+var454+var455+var456+var457+var458+var459+var460+var461+var462+var463+var464+var465+var466+var467+var468+var469+var470+var471+var472+var473+var474+var475+var476+var477+var478+var479+var480+var481+var482+var483+var484+var485+var486+var487+var488+var489+var490+var491+var492+var493+var494+var495+var496+var497+var498+var499))) + output = append(output, 1-var500) + output = append(output, var500) + return +} diff --git a/dep/msquic b/dep/msquic new file mode 160000 index 00000000..df4cc625 --- /dev/null +++ b/dep/msquic @@ -0,0 +1 @@ +Subproject commit df4cc6250ae7f1549ae974dabc50e1095c1c12af diff --git a/go.mod b/go.mod index 3ee66bef..ef10e359 100644 --- a/go.mod +++ b/go.mod @@ -18,6 +18,7 @@ require ( github.com/pion/logging v0.2.2 github.com/pion/turn/v3 v3.0.1 github.com/pkg/errors v0.9.1 + github.com/quic-go/quic-go v0.35.0 github.com/rs/zerolog v1.31.0 github.com/shirou/gopsutil v3.21.11+incompatible github.com/shirou/gopsutil/v3 v3.23.7 @@ -41,11 +42,16 @@ require ( github.com/kr/pretty v0.3.1 // indirect github.com/leodido/go-urn v1.2.4 // indirect github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect + github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect + github.com/golang/mock v1.6.0 // indirect + github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 // indirect + github.com/kr/pretty v0.3.1 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.19 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect github.com/pelletier/go-toml/v2 v2.0.9 // indirect + github.com/onsi/ginkgo/v2 v2.9.5 // indirect github.com/pion/dtls/v2 v2.2.7 // indirect github.com/pion/randutil v0.1.0 // indirect github.com/pion/stun/v2 v2.0.0 // indirect @@ -54,6 +60,8 @@ require ( github.com/pmezard/go-difflib v1.0.0 // indirect github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect github.com/shoenig/go-m1cpu v0.1.6 // indirect + github.com/quic-go/qtls-go1-19 v0.3.2 // indirect + github.com/quic-go/qtls-go1-20 v0.3.3 // indirect github.com/tklauser/go-sysconf v0.3.11 // indirect github.com/tklauser/numcpus v0.6.0 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect @@ -61,9 +69,12 @@ require ( github.com/yusufpapurcu/wmi v1.2.3 // indirect golang.org/x/arch v0.4.0 // indirect golang.org/x/crypto v0.13.0 // indirect + golang.org/x/exp v0.0.0-20221205204356-47842c84f3db // indirect + golang.org/x/mod v0.10.0 // indirect golang.org/x/net v0.15.0 // indirect golang.org/x/sys v0.12.0 // indirect golang.org/x/text v0.13.0 // indirect google.golang.org/protobuf v1.31.0 // indirect + golang.org/x/tools v0.9.1 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect ) diff --git a/go.sum b/go.sum index 5581b955..3887e131 100644 --- a/go.sum +++ b/go.sum @@ -6,6 +6,8 @@ github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY github.com/archdx/zerolog-sentry v1.2.0 h1:FDFqlo5XvL/jpDAPoAWI15EjJQVFvixn70v3IH//eTM= github.com/archdx/zerolog-sentry v1.2.0/go.mod h1:3H8gClGFafB90fKMsvfP017bdmkG5MD6UiA+6iPEwGw= github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g= +github.com/archdx/zerolog-sentry v1.5.0 h1:wc3arq95hz749M2iPwfSb7jzdYhTch4AK/opofXHcNs= +github.com/archdx/zerolog-sentry v1.5.0/go.mod h1:shfLC+5jaXkS1iBcAD/k07g5QH1M/jbPcVr5DkZyxk4= github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs= github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM= @@ -15,8 +17,12 @@ github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams= github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk= github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -35,8 +41,14 @@ github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SU github.com/go-errors/errors v1.0.1 h1:LUHzmkK3GUKUrL/1gfBUxAHzcev3apQlezX/+O7ma6w= github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8= +github.com/getsentry/sentry-go v0.24.1 h1:W6/0GyTy8J6ge6lVCc94WB6Gx2ZuLrgopnn9w8Hiwuk= +github.com/getsentry/sentry-go v0.24.1/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= +github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= +github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI= +github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls= github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= @@ -47,6 +59,12 @@ github.com/go-playground/validator/v10 v10.14.1/go.mod h1:9iXMNT7sEkjXb0I+enO7QX github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 h1:yAJXTCF9TqKcTiHJAE8dj7HMvPfh66eeA2JYW7eFpSE= +github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= github.com/golang-jwt/jwt/v5 v5.0.0 h1:1n1XNM9hk7O9mnQoNBGolZvzebBQ7p93ULHRc28XJUE= github.com/golang-jwt/jwt/v5 v5.0.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= @@ -61,6 +79,7 @@ github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWm github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/hashicorp/golang-lru/v2 v2.0.3 h1:kmRrRLlInXvng0SmLxmQpQkpbYAvcXm7NPDrgxJa9mE= github.com/hashicorp/golang-lru/v2 v2.0.3/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA= github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI= github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk= @@ -70,6 +89,10 @@ github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8= github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= github.com/jonboulle/clockwork v0.2.2 h1:UOGuzwb1PwsrDAObMuhUnj0p5ULPj8V/xJ7Kx9qUBdQ= github.com/jonboulle/clockwork v0.2.2/go.mod h1:Pkfl5aHPm1nk2H9h0bjmnJD/BcgbGXUBGnn1kMkgxc8= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8= @@ -92,10 +115,12 @@ github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc h1:RKf14vYWi2t github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc/go.mod h1:kopuH9ugFRkIXf3YoqHKyrJ9YfUFsckUU9S7B+XP+is= github.com/lestrrat-go/strftime v1.0.5 h1:A7H3tT8DhTz8u65w+JRpiBxM4dINQhUXAZnhBa2xeOE= github.com/lestrrat-go/strftime v1.0.5/go.mod h1:E1nN3pCbtMSu1yjSVeyuRFVm/U0xoR76fd03sz+Qz4g= +github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4= github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= @@ -110,8 +135,10 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ= github.com/pelletier/go-toml/v2 v2.0.9 h1:uH2qQXheeefCCkuBBSLi7jCiSmj3VRh2+Goq2N7Xxu0= github.com/pelletier/go-toml/v2 v2.0.9/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= +github.com/onsi/ginkgo/v2 v2.9.5 h1:+6Hr4uxzP4XIUyAkg61dWBw8lb/gc4/X5luuxN/EC+Q= +github.com/onsi/ginkgo/v2 v2.9.5/go.mod h1:tvAoo1QUJwNEU2ITftXTpR7R1RbCzoZUOs3RonqW57k= +github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= -github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= github.com/pion/dtls/v2 v2.2.7 h1:cSUBsETxepsCSFSxC3mc/aDo14qQLMSL+O6IjG28yV8= github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s= github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY= @@ -128,16 +155,27 @@ github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9 github.com/pion/turn/v3 v3.0.1 h1:wLi7BTQr6/Q20R0vt/lHbjv6y4GChFtC33nkYbasoT8= github.com/pion/turn/v3 v3.0.1/go.mod h1:MrJDKgqryDyWy1/4NT9TWfXWGMC7UHT6pJIv1+gMeNE= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/quic-go/qtls-go1-19 v0.3.2 h1:tFxjCFcTQzK+oMxG6Zcvp4Dq8dx4yD3dDiIiyc86Z5U= +github.com/quic-go/qtls-go1-19 v0.3.2/go.mod h1:ySOI96ew8lnoKPtSqx2BlI5wCpUVPT05RMAlajtnyOI= +github.com/quic-go/qtls-go1-20 v0.3.3 h1:17/glZSLI9P9fDAeyCHBFSWSqJcwx1byhLwP5eUIDCM= +github.com/quic-go/qtls-go1-20 v0.3.3/go.mod h1:X9Nh97ZL80Z+bX/gUXMbipO6OxdiDi58b/fMC9mAL+k= +github.com/quic-go/quic-go v0.35.0 h1:JXIf219xJK+4qGeY52rlnrVqeB2AXUAwfLU9JSoWXwg= +github.com/quic-go/quic-go v0.35.0/go.mod h1:+4CVgVppm0FNjpG3UcX8Joi/frKOH7/ciD5yGcwOO1g= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/zerolog v1.30.0 h1:SymVODrcRsaRaSInD9yQtKbtWqwsfoPcRff/oRXLj4c= +github.com/rs/zerolog v1.30.0/go.mod h1:/tk+P47gFdPXq4QYjvCmT5/Gsug2nagsFWBWhAiSi1w= github.com/rs/zerolog v1.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A= github.com/rs/zerolog v1.31.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= @@ -157,6 +195,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+ github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= @@ -169,6 +208,7 @@ github.com/tklauser/go-sysconf v0.3.11 h1:89WgdJhk5SNwJfu+GKyYveZ4IaJ7xAkecBo+Kd github.com/tklauser/go-sysconf v0.3.11/go.mod h1:GqXfhXY3kiPa0nAXPDIQIWzJbMCB7AmcWpGR8lSZfqI= github.com/tklauser/numcpus v0.6.0 h1:kebhY2Qt+3U6RNK7UqpYNA+tJ23IBEGKkB7JQBfDYms= github.com/tklauser/numcpus v0.6.0/go.mod h1:FEZLMke0lhOUG6w2JadTzp0a+Nl8PF/GFkQ5UVIcaL4= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= @@ -188,15 +228,23 @@ golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUu golang.org/x/arch v0.4.0 h1:A8WCeEWhLwPBKNbFi5Wv5UTCBx5zzubnXDlMOFAzFMc= golang.org/x/arch v0.4.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE= golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck= golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= +golang.org/x/exp v0.0.0-20221205204356-47842c84f3db h1:D/cFflL63o2KSLJIwjlcIt8PR064j/xsmdEJL/YvY/o= +golang.org/x/exp v0.0.0-20221205204356-47842c84f3db/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk= +golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= @@ -205,13 +253,20 @@ golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= golang.org/x/net v0.15.0 h1:ugBLEUaxABaB5AJqW9enI0ACdci2RUd4eP51NTBvuJ8= golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -238,12 +293,17 @@ golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k= golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= -golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.9.1 h1:8WMNJAz3zrtPmnYC7ISf5dEn3MT0gY7jBJfw27yrrLo= +golang.org/x/tools v0.9.1/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.29.1 h1:7QBf+IK2gx70Ap/hDsOmam3GE0v9HicjfEdAxE62UoM= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= diff --git a/server/config.go b/server/config.go index 7323248f..54914d75 100644 --- a/server/config.go +++ b/server/config.go @@ -99,6 +99,9 @@ type Options struct { Password string `arg:"password" yaml:"password,omitempty" json:"-" usage:"Admin password use for login in web server"` Signal string `arg:"s" yaml:"-" json:"-" usage:"Send signal to client processes. Supports values: restart, stop, kill"` + + QuicAddr string `yaml:"quicAddr" usage:"The address for quic connection (between GT client and GT server) to listen on. Supports values like: '443', ':443' or '0.0.0.0:443'"` + OpenBBR bool `yaml:"bbr" usage:"Use bbr as congestion control algorithm (through msquic) when GT use QUIC connection. Default algorithm is Cubic (through quic-go)."` } func defaultConfig() Config { @@ -124,6 +127,8 @@ func defaultConfig() Config { HostNumber: 0, MaxHandShakeOptions: 30, + + OpenBBR: false, }, } } diff --git a/server/conn.go b/server/conn.go index 7c57faa9..01523ede 100644 --- a/server/conn.go +++ b/server/conn.go @@ -18,6 +18,7 @@ import ( "bytes" "crypto/sha256" "errors" + "github.com/quic-go/quic-go" "io" "net" "runtime/debug" @@ -137,13 +138,20 @@ func (c *conn) handle(handleFunc func() bool) { c.Logger = c.Logger.With().Time("tunnel", time.Now()).Logger() - // 判断 IP 是否处于被限制状态 - remoteAddr, ok := c.RemoteAddr().(*net.TCPAddr) - if !ok { - c.Logger.Warn().Msg("conn is not tcp conn") - return + remoteTcpAddr, okTcp := c.RemoteAddr().(*net.TCPAddr) + var remoteIP string + if okTcp { + remoteIP = remoteTcpAddr.IP.String() + } else { + remoteUdpAddr, okUdp := c.RemoteAddr().(*net.UDPAddr) + if okUdp { + remoteIP = remoteUdpAddr.IP.String() + } else { + c.Logger.Warn().Msg("conn is not tcp/udp conn") + return + } } - remoteIP := remoteAddr.IP.String() + c.server.reconnectRWMutex.RLock() reconnectTimes := c.server.reconnect[remoteIP] c.server.reconnectRWMutex.RUnlock() @@ -155,6 +163,34 @@ func (c *conn) handle(handleFunc func() bool) { // 不能将 reconnectTimes 传参，多线程环境下这个值应该实时获取 handled = c.handleTunnelLoop(remoteIP) return + case 0x02: + var buf []byte + probeCloseError := &quic.ApplicationError{ + Remote: true, + ErrorCode: 0x42, + ErrorMessage: "close QUIC probe connection", + } + for { + timer := time.AfterFunc(3*time.Second, func() { + c.Logger.Info().Msg("closing QUIC probe connection") + }) + if buf, err = c.Connection.Conn.(*connection.QuicConnection).ReceiveMessage(); err != nil { + if err.Error() == probeCloseError.Error() { + break + } else { + c.Logger.Warn().Err(err).Msg("failed to use QUIC probe connection to receive message") + return + } + } + err = c.Connection.Conn.(*connection.QuicConnection).SendMessage(buf) + if err != nil { + c.Logger.Warn().Err(err).Msg("failed to use QUIC probe connection to send message") + return + } + timer.Stop() + } + handled = true + return } } handled = handleFunc() diff --git a/server/server.go b/server/server.go index 54d16b55..2c084748 100644 --- a/server/server.go +++ b/server/server.go @@ -20,6 +20,8 @@ import ( "encoding/json" "errors" "fmt" + connection "github.com/isrc-cas/gt/conn" + "github.com/isrc-cas/gt/conn/msquic" "github.com/pion/turn/v3" "github.com/shirou/gopsutil/process" "io" @@ -59,6 +61,7 @@ type Server struct { tlsListener net.Listener listener net.Listener sniListener net.Listener + quicListener net.Listener accepted uint64 served uint64 failed uint64 @@ -236,6 +239,34 @@ func (s *Server) listen() (err error) { return } +func (s *Server) quicListen(openBBR bool) (err error) { + var tlsConfig *tls.Config + if len(s.config.CertFile) > 0 && len(s.config.KeyFile) > 0 { + tlsConfig, err = newTLSConfig(s.config.CertFile, s.config.KeyFile, s.config.TLSMinVersion) + } else { + tlsConfig = connection.GenerateTLSConfig() + } + if err != nil { + return + } + if openBBR { + //s.quicListener, err = connection.QuicBbrListen(s.config.QuicAddr, tlsConfig) + //s.quicListener, err = quic.NewListenr(s.config.QuicAddr, 10_000, s.config.KeyFile, s.config.CertFile, "") + s.quicListener, err = msquic.MsquicListen(s.config.QuicAddr, s.config.KeyFile, s.config.CertFile) + } else { + s.quicListener, err = connection.QuicListen(s.config.QuicAddr, tlsConfig) + } + if err != nil { + err = fmt.Errorf("can not listen on addr '%s', cause %s, please check option 'addr'", s.config.QuicAddr, err.Error()) + return + } + s.Logger.Info().Str("QuicAddr", s.quicListener.Addr().String()).Msg("Listening") + go s.acceptLoop(s.quicListener, func(c *conn) { + c.handle(c.handleHTTP) + }) + return +} + func (s *Server) sniListen() (err error) { s.sniListener, err = net.Listen("tcp", s.config.SNIAddr) if err != nil { @@ -364,6 +395,24 @@ func (s *Server) Start() (err error) { } listening = true } + if len(s.config.QuicAddr) > 0 { + //if strings.IndexByte(s.config.QuicAddr, ':') == -1 { + // s.config.QuicAddr = ":" + s.config.QuicAddr + //} + // TODO Go 的冒号加空格会同时监听 IPv4 和 IPv6，这里行为与其他的不一致 + colonIndex := strings.IndexByte(s.config.QuicAddr, ':') + if colonIndex == -1 { + s.config.QuicAddr = "0.0.0.0:" + s.config.QuicAddr + } + if colonIndex == 0 { + s.config.QuicAddr = "0.0.0.0" + s.config.QuicAddr + } + err = s.quicListen(s.config.OpenBBR) + if err != nil { + return + } + listening = true + } if len(s.config.Addr) > 0 { if strings.IndexByte(s.config.Addr, ':') == -1 { s.config.Addr = ":" + s.config.Addr @@ -1034,6 +1083,15 @@ func (s *Server) GetTLSListenerAddrPort() (addrPort netip.AddrPort) { return } +// GetQuicListenerAddrPort 获取 QUIC listener 地址，返回值可能为空 +func (s *Server) GetQuicListenerAddrPort() (addrPort string) { + if s.tlsListener == nil { + return + } + addrPort = s.quicListener.Addr().String() + return +} + // GetAPIListenerAddrPort 获取 api listener 地址，返回值可能为空 func (s *Server) GetAPIListenerAddrPort() (addrPort netip.AddrPort) { if s.apiListener == nil { diff --git a/test/quic_test.go b/test/quic_test.go new file mode 100644 index 00000000..3300b382 --- /dev/null +++ b/test/quic_test.go @@ -0,0 +1,129 @@ +// Copyright (c) 2022 Institute of Software, Chinese Academy of Sciences (ISCAS) +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package test + +import ( + "errors" + "io" + "net" + "net/http" + "os" + "testing" +) + +func TestQuic(t *testing.T) { + t.Parallel() + mux := http.NewServeMux() + mux.HandleFunc("/test", func(writer http.ResponseWriter, request *http.Request) { + err := request.ParseForm() + if err != nil { + panic(err) + } + if request.FormValue("hello") != "world" { + writer.WriteHeader(http.StatusBadRequest) + return + } + _, err = writer.Write([]byte("ok")) + if err != nil { + panic(err) + } + }) + hs := &http.Server{Handler: mux} + l, err := net.Listen("tcp", "127.0.0.1:8080") + if err != nil { + t.Fatal(err) + } + defer func() { + err := hs.Close() + if err != nil { + t.Fatal(err) + } + }() + go func() { + err := hs.Serve(l) + if err != nil && !errors.Is(err, http.ErrServerClosed) { + panic(err) + } + }() + + // 生成 TLS 证书 + const ( + keyFile = "tls.key" + certFile = "tls.crt" + ) + err = generateTLSKeyAndCert("*.example.com,localhost", keyFile, certFile) + if err != nil { + t.Fatal(err) + } + defer func() { + err = os.Remove(keyFile) + if err != nil { + t.Fatal(err) + } + err = os.Remove(certFile) + if err != nil { + t.Fatal(err) + } + }() + + // 启动服务端、客户端 + s, err := setupServer([]string{ + "server", + "-addr", "127.0.0.1:12080", + "-quicAddr", "127.0.0.1:12880", + "-id", "05797ac9-86ae-40b0-b767-7a41e03a5486", + "-secret", "eec1eabf-2c59-4e19-bf10-34707c17ed89", + "-keyFile", keyFile, + "-certFile", certFile, + }, nil) + if err != nil { + t.Fatal(err) + } + defer s.Close() + c, err := setupClient([]string{ + "client", + "-id", "05797ac9-86ae-40b0-b767-7a41e03a5486", + "-secret", "eec1eabf-2c59-4e19-bf10-34707c17ed89", + "-local", "http://127.0.0.1:8080", + "-remote", "quic://127.0.0.1:12880", + "-remoteTimeout", "5s", + "-remoteCertInsecure", + }, nil) + if err != nil { + t.Fatal(err) + } + defer c.Close() + + // 通过 https 测试 + httpClient := setupHTTPClient(s.GetListenerAddrPort().String(), nil) + resp, err := httpClient.Get("http://05797ac9-86ae-40b0-b767-7a41e03a5486.example.com/test?hello=world") + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + t.Fatal("invalid status code") + } + all, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err) + } + if string(all) != "ok" { + t.Fatal("invalid resp") + } + c.OnTunnelClose.Store(func() {}) + t.Logf("%s", all) + s.Shutdown() +}